opensteer 0.9.6 → 0.9.8

package/dist/cli/bin.cjs

@@ -1662,31 +1662,131 @@ function isAlreadyExistsError(error) {
 }
 async function withFilesystemLock(lockPath, task) {
   await ensureDirectory(path10__default.default.dirname(lockPath));
+  const ownerToken = crypto.randomUUID();
   let attempt = 0;
   while (true) {
     try {
       await promises.mkdir(lockPath);
+      const acquiredAt = Date.now();
+      await writeLockMetadata(lockPath, {
+        version: LOCK_METADATA_VERSION,
+        ownerToken,
+        pid: process.pid,
+        acquiredAt,
+        heartbeatAt: acquiredAt
+      });
       break;
     } catch (error) {
       if (!isAlreadyExistsError(error)) {
         throw error;
       }
+      if (await tryRecoverFilesystemLock(lockPath)) {
+        attempt = 0;
+        continue;
+      }
       const delayMs = LOCK_RETRY_DELAYS_MS[Math.min(attempt, LOCK_RETRY_DELAYS_MS.length - 1)];
       attempt += 1;
       await new Promise((resolve4) => setTimeout(resolve4, delayMs));
     }
   }
+  const heartbeatTimer = setInterval(() => {
+    void touchLockMetadata(lockPath, ownerToken);
+  }, LOCK_HEARTBEAT_INTERVAL_MS);
+  heartbeatTimer.unref?.();
   try {
     return await task();
   } finally {
-    await promises.rm(lockPath, { recursive: true, force: true });
+    clearInterval(heartbeatTimer);
+    const metadata = await readLockMetadata(lockPath);
+    if (metadata?.ownerToken === ownerToken) {
+      await promises.rm(lockPath, { recursive: true, force: true });
+    }
   }
 }
-var LOCK_RETRY_DELAYS_MS;
+async function tryRecoverFilesystemLock(lockPath) {
+  if (!await shouldRecoverFilesystemLock(lockPath)) {
+    return false;
+  }
+  await promises.rm(lockPath, { recursive: true, force: true });
+  return true;
+}
+async function shouldRecoverFilesystemLock(lockPath) {
+  const metadata = await readLockMetadata(lockPath);
+  if (metadata !== void 0) {
+    if (isProcessRunning2(metadata.pid)) {
+      return false;
+    }
+    return Date.now() - metadata.heartbeatAt >= LOCK_ORPHAN_GRACE_MS;
+  }
+  const lockStat = await promises.stat(lockPath).catch(() => void 0);
+  if (lockStat === void 0) {
+    return false;
+  }
+  return Date.now() - lockStat.mtimeMs >= LOCK_METADATALESS_STALE_MS;
+}
+async function readLockMetadata(lockPath) {
+  const metadataPath = path10__default.default.join(lockPath, LOCK_METADATA_FILENAME);
+  if (!await pathExists(metadataPath)) {
+    return void 0;
+  }
+  try {
+    const parsed = await readJsonFile(metadataPath);
+    const pid = parsed.pid;
+    const acquiredAt = parsed.acquiredAt;
+    const heartbeatAt = parsed.heartbeatAt;
+    if (parsed.version !== LOCK_METADATA_VERSION || typeof parsed.ownerToken !== "string" || parsed.ownerToken.length === 0 || typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof acquiredAt !== "number" || !Number.isFinite(acquiredAt) || typeof heartbeatAt !== "number" || !Number.isFinite(heartbeatAt)) {
+      return void 0;
+    }
+    return {
+      version: LOCK_METADATA_VERSION,
+      ownerToken: parsed.ownerToken,
+      pid,
+      acquiredAt,
+      heartbeatAt
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeLockMetadata(lockPath, metadata) {
+  try {
+    await writeJsonFileAtomic(path10__default.default.join(lockPath, LOCK_METADATA_FILENAME), metadata);
+  } catch (error) {
+    await promises.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function touchLockMetadata(lockPath, ownerToken) {
+  const metadata = await readLockMetadata(lockPath);
+  if (metadata === void 0 || metadata.ownerToken !== ownerToken) {
+    return;
+  }
+  await writeJsonFileAtomic(path10__default.default.join(lockPath, LOCK_METADATA_FILENAME), {
+    ...metadata,
+    heartbeatAt: Date.now()
+  }).catch(() => void 0);
+}
+function isProcessRunning2(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+var LOCK_RETRY_DELAYS_MS, LOCK_METADATA_FILENAME, LOCK_METADATA_VERSION, LOCK_HEARTBEAT_INTERVAL_MS, LOCK_ORPHAN_GRACE_MS, LOCK_METADATALESS_STALE_MS;
 var init_filesystem = __esm({
   "../runtime-core/src/internal/filesystem.ts"() {
     init_json();
     LOCK_RETRY_DELAYS_MS = [1, 2, 5, 10, 20, 50];
+    LOCK_METADATA_FILENAME = "owner.json";
+    LOCK_METADATA_VERSION = 1;
+    LOCK_HEARTBEAT_INTERVAL_MS = 1e3;
+    LOCK_ORPHAN_GRACE_MS = 2e3;
+    LOCK_METADATALESS_STALE_MS = 3e4;
   }
 });
 function normalizeScope(scope) {
@@ -2294,7 +2394,7 @@ var init_version = __esm({
   "../protocol/src/version.ts"() {
     init_json2();
     OPENSTEER_PROTOCOL_NAME = "opensteer";
-    OPENSTEER_PROTOCOL_COMPATIBILITY_REVISION = 2;
+    OPENSTEER_PROTOCOL_COMPATIBILITY_REVISION = 3;
     OPENSTEER_PROTOCOL_VERSION = `0.${OPENSTEER_PROTOCOL_COMPATIBILITY_REVISION}.0`;
     OPENSTEER_PROTOCOL_MEDIA_TYPE = `application/vnd.${OPENSTEER_PROTOCOL_NAME}+json;version=${OPENSTEER_PROTOCOL_VERSION}`;
     OPENSTEER_PROTOCOL_REST_BASE_PATH = `/api/v${OPENSTEER_PROTOCOL_COMPATIBILITY_REVISION}`;
@@ -2840,6 +2940,9 @@ var init_metadata2 = __esm({
       {
         pageRef: pageRefSchema,
         sessionRef: sessionRefSchema,
+        targetId: stringSchema({
+          description: "Underlying browser target identifier when available."
+        }),
         openerPageRef: pageRefSchema,
         url: stringSchema({
           description: "Current main-frame URL."
@@ -6677,15 +6780,15 @@ function assertValidSemanticOperationInput(name, input) {
     }
   );
 }
-var opensteerComputerAnnotationNames, opensteerExposedSemanticOperationNames, opensteerPackageRunnableSemanticOperationNames, snapshotModeSchema, viewportSchema, opensteerBrowserLaunchOptionsSchema, attachBrowserOptionsSchema, opensteerBrowserOptionsSchema, opensteerBrowserContextOptionsSchema, targetByElementSchema2, targetByPersistSchema2, targetBySelectorSchema2, opensteerTargetInputSchema, opensteerResolvedTargetSchema, opensteerActionResultSchema, opensteerSnapshotCounterSchema, opensteerSessionStateSchema, opensteerOpenInputSchema, opensteerPageListInputSchema, opensteerPageListOutputSchema, opensteerPageNewInputSchema, opensteerPageActivateInputSchema, opensteerPageCloseInputSchema, opensteerPageCloseOutputSchema, opensteerPageGotoInputSchema, opensteerPageEvaluateInputSchema, opensteerPageEvaluateOutputSchema, opensteerAddInitScriptInputSchema, opensteerAddInitScriptOutputSchema, opensteerCapturedScriptSchema, opensteerCaptureScriptsInputSchema, opensteerCaptureScriptsOutputSchema, opensteerPageSnapshotInputSchema, opensteerPageSnapshotOutputSchema, opensteerComputerMouseButtonSchema, opensteerComputerKeyModifierSchema, opensteerDomClickInputSchema, opensteerDomHoverInputSchema, opensteerDomInputInputSchema, opensteerDomScrollInputSchema, opensteerExtractTemplateSchema, opensteerDomExtractInputSchema, jsonValueSchema2, opensteerDomExtractOutputSchema, opensteerSessionCloseInputSchema, opensteerSessionCloseOutputSchema, opensteerComputerAnnotationSchema, opensteerComputerClickActionSchema, opensteerComputerMoveActionSchema, opensteerComputerScrollActionSchema, opensteerComputerTypeActionSchema, opensteerComputerKeyActionSchema, opensteerComputerDragActionSchema, opensteerComputerScreenshotActionSchema, opensteerComputerWaitActionSchema, opensteerComputerActionSchema, opensteerComputerScreenshotOptionsSchema, opensteerComputerExecuteInputSchema, opensteerComputerTracePointSchema, opensteerComputerTraceEnrichmentSchema, opensteerComputerExecuteTimingSchema, opensteerComputerDisplayScaleSchema, opensteerComputerExecuteOutputSchema, opensteerSemanticOperationSpecificationsBase, exposedSemanticOperationNameSet, opensteerSemanticOperationSpecificationsInternal, opensteerSemanticOperationSpecifications, opensteerSemanticOperationSpecificationMap, semanticRestBasePath, opensteerSemanticRestEndpoints;
+var opensteerComputerAnnotationNames, opensteerExposedSemanticOperationNames, opensteerPackageRunnableSemanticOperationNames, snapshotModeSchema, viewportSchema, opensteerBrowserLaunchOptionsSchema, attachBrowserOptionsSchema, opensteerBrowserOptionsSchema, opensteerBrowserContextOptionsSchema, targetByElementSchema2, targetByPersistSchema2, targetBySelectorSchema2, opensteerTargetInputSchema, opensteerActionResultSchema, opensteerSnapshotCounterSchema, opensteerNavigationSummarySchema, opensteerOpenInputSchema, opensteerPageListInputSchema, opensteerPageListOutputSchema, opensteerPageNewInputSchema, opensteerPageActivateInputSchema, opensteerPageCloseInputSchema, opensteerPageCloseOutputSchema, opensteerPageNewOutputSchema, opensteerPageGotoInputSchema, opensteerPageEvaluateInputSchema, opensteerPageEvaluateOutputSchema, opensteerAddInitScriptInputSchema, opensteerAddInitScriptOutputSchema, opensteerCapturedScriptSchema, opensteerCaptureScriptsInputSchema, opensteerCaptureScriptsOutputSchema, opensteerPageSnapshotInputSchema, opensteerPageSnapshotOutputSchema, opensteerComputerMouseButtonSchema, opensteerComputerKeyModifierSchema, opensteerDomClickInputSchema, opensteerDomHoverInputSchema, opensteerDomInputInputSchema, opensteerDomScrollInputSchema, opensteerExtractTemplateSchema, opensteerDomExtractInputSchema, jsonValueSchema2, opensteerDomExtractOutputSchema, opensteerSessionCloseInputSchema, opensteerSessionCloseOutputSchema, opensteerComputerAnnotationSchema, opensteerComputerClickActionSchema, opensteerComputerMoveActionSchema, opensteerComputerScrollActionSchema, opensteerComputerTypeActionSchema, opensteerComputerKeyActionSchema, opensteerComputerDragActionSchema, opensteerComputerScreenshotActionSchema, opensteerComputerWaitActionSchema, opensteerComputerActionSchema, opensteerComputerScreenshotOptionsSchema, opensteerComputerExecuteInputSchema, opensteerScreenshotSummarySchema, opensteerComputerExecuteOutputSchema, opensteerSemanticOperationSpecificationsBase, exposedSemanticOperationNameSet, opensteerSemanticOperationSpecificationsInternal, opensteerSemanticOperationSpecifications, opensteerSemanticOperationSpecificationMap, semanticRestBasePath, opensteerSemanticRestEndpoints;
 var init_semantic = __esm({
   "../protocol/src/semantic.ts"() {
     init_json2();
     init_errors2();
+    init_binary_location();
     init_identity2();
     init_geometry2();
     init_metadata2();
-    init_events2();
     init_envelopes();
     init_snapshots2();
     init_artifacts2();
@@ -6909,39 +7012,14 @@ var init_semantic = __esm({
         title: "OpensteerTargetInput"
       }
     );
-    opensteerResolvedTargetSchema = objectSchema(
-      {
-        pageRef: pageRefSchema,
-        frameRef: frameRefSchema,
-        documentRef: documentRefSchema,
-        documentEpoch: documentEpochSchema,
-        nodeRef: nodeRefSchema,
-        tagName: stringSchema(),
-        pathHint: stringSchema(),
-        persist: stringSchema(),
-        selectorUsed: stringSchema()
-      },
-      {
-        title: "OpensteerResolvedTarget",
-        required: [
-          "pageRef",
-          "frameRef",
-          "documentRef",
-          "documentEpoch",
-          "nodeRef",
-          "tagName",
-          "pathHint"
-        ]
-      }
-    );
     opensteerActionResultSchema = objectSchema(
       {
-        target: opensteerResolvedTargetSchema,
-        point: pointSchema
+        tagName: stringSchema({ minLength: 1 }),
+        persist: stringSchema({ minLength: 1 })
       },
       {
         title: "OpensteerActionResult",
-        required: ["target"]
+        required: ["tagName"]
       }
     );
     opensteerSnapshotCounterSchema = objectSchema(
@@ -6987,16 +7065,14 @@ var init_semantic = __esm({
         ]
       }
     );
-    opensteerSessionStateSchema = objectSchema(
+    opensteerNavigationSummarySchema = objectSchema(
       {
-        sessionRef: sessionRefSchema,
-        pageRef: pageRefSchema,
         url: stringSchema(),
         title: stringSchema()
       },
       {
-        title: "OpensteerSessionState",
-        required: ["sessionRef", "pageRef", "url", "title"]
+        title: "OpensteerNavigationSummary",
+        required: ["url", "title"]
       }
     );
     opensteerOpenInputSchema = objectSchema(
@@ -7064,6 +7140,17 @@ var init_semantic = __esm({
         required: ["closedPageRef", "pages"]
       }
     );
+    opensteerPageNewOutputSchema = objectSchema(
+      {
+        pageRef: pageRefSchema,
+        url: stringSchema(),
+        title: stringSchema()
+      },
+      {
+        title: "OpensteerPageNewOutput",
+        required: ["pageRef", "url", "title"]
+      }
+    );
     opensteerPageGotoInputSchema = objectSchema(
       {
         url: stringSchema(),
@@ -7450,72 +7537,28 @@ var init_semantic = __esm({
         required: ["action"]
       }
     );
-    opensteerComputerTracePointSchema = objectSchema(
-      {
-        role: enumSchema(["point", "start", "end"]),
-        point: pointSchema,
-        hitTest: hitTestResultSchema,
-        target: opensteerResolvedTargetSchema
-      },
-      {
-        title: "OpensteerComputerTracePoint",
-        required: ["role", "point"]
-      }
-    );
-    opensteerComputerTraceEnrichmentSchema = objectSchema(
-      {
-        points: arraySchema(opensteerComputerTracePointSchema)
-      },
-      {
-        title: "OpensteerComputerTraceEnrichment",
-        required: ["points"]
-      }
-    );
-    opensteerComputerExecuteTimingSchema = objectSchema(
-      {
-        actionMs: integerSchema({ minimum: 0 }),
-        waitMs: integerSchema({ minimum: 0 }),
-        totalMs: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerComputerExecuteTiming",
-        required: ["actionMs", "waitMs", "totalMs"]
-      }
-    );
-    opensteerComputerDisplayScaleSchema = objectSchema(
+    opensteerScreenshotSummarySchema = objectSchema(
       {
-        x: numberSchema({ exclusiveMinimum: 0 }),
-        y: numberSchema({ exclusiveMinimum: 0 })
+        payload: externalBinaryLocationSchema,
+        format: screenshotFormatSchema,
+        size: sizeSchema,
+        coordinateSpace: coordinateSpaceSchema,
+        clip: rectSchema
       },
       {
-        title: "OpensteerComputerDisplayScale",
-        required: ["x", "y"]
+        title: "OpensteerScreenshotSummary",
+        required: ["payload", "format", "size", "coordinateSpace"]
       }
     );
     opensteerComputerExecuteOutputSchema = objectSchema(
       {
-        action: opensteerComputerActionSchema,
-        pageRef: pageRefSchema,
-        screenshot: screenshotArtifactSchema,
-        displayViewport: viewportMetricsSchema,
-        nativeViewport: viewportMetricsSchema,
-        displayScale: opensteerComputerDisplayScaleSchema,
-        events: arraySchema(opensteerEventSchema),
-        timing: opensteerComputerExecuteTimingSchema,
-        trace: opensteerComputerTraceEnrichmentSchema
+        url: stringSchema(),
+        title: stringSchema(),
+        screenshot: opensteerScreenshotSummarySchema
       },
       {
         title: "OpensteerComputerExecuteOutput",
-        required: [
-          "action",
-          "pageRef",
-          "screenshot",
-          "displayViewport",
-          "nativeViewport",
-          "displayScale",
-          "events",
-          "timing"
-        ]
+        required: ["url", "title", "screenshot"]
       }
     );
     opensteerSemanticOperationSpecificationsBase = [
@@ -7523,7 +7566,7 @@ var init_semantic = __esm({
         name: "session.open",
         description: "Open or resume the current Opensteer session and primary page.",
         inputSchema: opensteerOpenInputSchema,
-        outputSchema: opensteerSessionStateSchema,
+        outputSchema: opensteerNavigationSummarySchema,
         requiredCapabilities: ["sessions.manage", "pages.manage"],
         resolveRequiredCapabilities: (input) => input.url === void 0 ? ["sessions.manage", "pages.manage"] : ["sessions.manage", "pages.manage", "pages.navigate"]
       }),
@@ -7538,7 +7581,7 @@ var init_semantic = __esm({
         name: "page.new",
         description: "Create and optionally navigate a new top-level page in the current session.",
         inputSchema: opensteerPageNewInputSchema,
-        outputSchema: opensteerSessionStateSchema,
+        outputSchema: opensteerPageNewOutputSchema,
         requiredCapabilities: ["pages.manage"],
         resolveRequiredCapabilities: (input) => input.url === void 0 ? ["pages.manage"] : ["pages.manage", "pages.navigate"]
       }),
@@ -7546,7 +7589,7 @@ var init_semantic = __esm({
         name: "page.activate",
         description: "Activate an existing top-level page in the current session.",
         inputSchema: opensteerPageActivateInputSchema,
-        outputSchema: opensteerSessionStateSchema,
+        outputSchema: opensteerNavigationSummarySchema,
         requiredCapabilities: ["pages.manage", "inspect.pages"]
       }),
       defineSemanticOperationSpec({
@@ -7560,7 +7603,7 @@ var init_semantic = __esm({
         name: "page.goto",
         description: "Navigate the current Opensteer page to a new URL.",
         inputSchema: opensteerPageGotoInputSchema,
-        outputSchema: opensteerSessionStateSchema,
+        outputSchema: opensteerNavigationSummarySchema,
         requiredCapabilities: ["pages.navigate"]
       }),
       defineSemanticOperationSpec({
@@ -9103,6 +9146,9 @@ var init_observations = __esm({
         this.store = store;
         this.sessionId = sessionId;
       }
+      configure(input) {
+        return this.store.configureSession(this.sessionId, input);
+      }
       append(input) {
         return this.store.appendEvent(this.sessionId, input);
       }
@@ -9133,40 +9179,14 @@ var init_observations = __esm({
         const sessionId = normalizeNonEmptyString("sessionId", input.sessionId);
         const openedAt = normalizeTimestamp("openedAt", input.openedAt ?? Date.now());
         const config = normalizeObservabilityConfig(input.config);
-        const redactor = createObservationRedactor(config);
-        this.redactors.set(sessionId, redactor);
-        const redactedLabels = redactor.redactLabels(config.labels);
-        const redactedTraceContext = redactor.redactTraceContext(config.traceContext);
-        await withFilesystemLock(this.sessionLockPath(sessionId), async () => {
-          const existing = await this.reconcileSessionManifest(sessionId);
-          if (existing === void 0) {
-            await ensureDirectory(this.sessionEventsDirectory(sessionId));
-            await ensureDirectory(this.sessionArtifactsDirectory(sessionId));
-            const session = {
-              sessionId,
-              profile: config.profile,
-              ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
-              ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
-              openedAt,
-              updatedAt: openedAt,
-              currentSequence: 0,
-              eventCount: 0,
-              artifactCount: 0
-            };
-            await writeJsonFileExclusive(this.sessionManifestPath(sessionId), session);
-            return;
-          }
-          const patched = {
-            ...existing,
-            profile: config.profile,
-            ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
-            ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
-            updatedAt: Math.max(existing.updatedAt, openedAt)
-          };
-          await writeJsonFileAtomic(this.sessionManifestPath(sessionId), patched);
-        });
+        await this.applySessionConfiguration(sessionId, config, openedAt);
         return new FilesystemSessionSink(this, sessionId);
       }
+      async configureSession(sessionId, input) {
+        const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? Date.now());
+        const config = normalizeObservabilityConfig(input.config);
+        await this.applySessionConfiguration(sessionId, config, updatedAt);
+      }
       async getSession(sessionId) {
         const manifestPath = this.sessionManifestPath(sessionId);
         if (!await pathExists(manifestPath)) {
@@ -9387,6 +9407,40 @@ var init_observations = __esm({
       sessionLockPath(sessionId) {
         return path10__default.default.join(this.sessionDirectory(sessionId), ".lock");
       }
+      async applySessionConfiguration(sessionId, config, timestamp) {
+        const redactor = createObservationRedactor(config);
+        this.redactors.set(sessionId, redactor);
+        const redactedLabels = redactor.redactLabels(config.labels);
+        const redactedTraceContext = redactor.redactTraceContext(config.traceContext);
+        await withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+          const existing = await this.reconcileSessionManifest(sessionId);
+          if (existing === void 0) {
+            await ensureDirectory(this.sessionEventsDirectory(sessionId));
+            await ensureDirectory(this.sessionArtifactsDirectory(sessionId));
+            const session = {
+              sessionId,
+              profile: config.profile,
+              ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
+              ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
+              openedAt: timestamp,
+              updatedAt: timestamp,
+              currentSequence: 0,
+              eventCount: 0,
+              artifactCount: 0
+            };
+            await writeJsonFileExclusive(this.sessionManifestPath(sessionId), session);
+            return;
+          }
+          const patched = {
+            ...existing,
+            profile: config.profile,
+            ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
+            ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
+            updatedAt: Math.max(existing.updatedAt, timestamp)
+          };
+          await writeJsonFileAtomic(this.sessionManifestPath(sessionId), patched);
+        });
+      }
       async reconcileSessionManifest(sessionId) {
         const session = await this.getSession(sessionId);
         if (session === void 0) {
@@ -9802,16 +9856,37 @@ async function writePersistedSessionRecord(rootPath, record) {
 async function clearPersistedSessionRecord(rootPath, provider) {
   await promises.rm(resolveLiveSessionRecordPath(rootPath, provider), { force: true });
 }
+function getPersistedLocalBrowserSessionOwnership(record) {
+  return record.ownership === "attached" ? "attached" : "owned";
+}
+async function isAttachedLocalBrowserSessionReachable(record) {
+  if (getPersistedLocalBrowserSessionOwnership(record) !== "attached") {
+    return false;
+  }
+  if (record.engine !== "playwright" || record.endpoint === void 0) {
+    return false;
+  }
+  try {
+    await inspectCdpEndpoint({
+      endpoint: record.endpoint,
+      timeoutMs: 1500
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function isPersistedCloudSessionRecord(value) {
-  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && (value.activePageUrl === void 0 || typeof value.activePageUrl === "string") && (value.activePageTitle === void 0 || typeof value.activePageTitle === "string") && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
 }
 function isPersistedLocalBrowserSessionRecord(value) {
-  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "local" && (value.engine === "playwright" || value.engine === "abp") && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) && typeof value.userDataDir === "string" && value.userDataDir.length > 0;
+  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "local" && (value.engine === "playwright" || value.engine === "abp") && (value.ownership === void 0 || value.ownership === "owned" || value.ownership === "attached") && (value.activePageUrl === void 0 || typeof value.activePageUrl === "string") && (value.activePageTitle === void 0 || typeof value.activePageTitle === "string") && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) && typeof value.userDataDir === "string" && value.userDataDir.length > 0;
 }
 var OPENSTEER_LIVE_SESSION_LAYOUT, OPENSTEER_LIVE_SESSION_VERSION;
 var init_live_session = __esm({
   "src/live-session.ts"() {
     init_filesystem2();
+    init_cdp_discovery();
     OPENSTEER_LIVE_SESSION_LAYOUT = "opensteer-session";
     OPENSTEER_LIVE_SESSION_VERSION = 1;
   }
@@ -10300,19 +10375,40 @@ var init_service = __esm({
   }
 });
 function buildLocalViewSessionId(input) {
+  const ownership = input.ownership ?? "owned";
+  const identity = ownership === "attached" ? input.endpoint ?? input.remoteDebuggingUrl ?? input.baseUrl ?? "attached" : `pid:${String(input.pid ?? 0)}`;
   const hash = crypto.createHash("sha256").update(`${input.rootPath}
-${String(input.pid)}
+${ownership}
+${identity}
 ${String(input.startedAt)}`).digest("hex");
   return `local_${hash.slice(0, 24)}`;
 }
+function buildLocalViewSessionIdForRecord(input) {
+  const ownership = getPersistedLocalBrowserSessionOwnership(input.live);
+  if (ownership === "attached") {
+    return buildLocalViewSessionId({
+      rootPath: input.rootPath,
+      ownership,
+      startedAt: input.live.startedAt,
+      ...input.live.endpoint === void 0 ? {} : { endpoint: input.live.endpoint },
+      ...input.live.baseUrl === void 0 ? {} : { baseUrl: input.live.baseUrl },
+      ...input.live.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: input.live.remoteDebuggingUrl }
+    });
+  }
+  return buildLocalViewSessionId({
+    rootPath: input.rootPath,
+    ownership,
+    startedAt: input.live.startedAt,
+    pid: input.live.pid
+  });
+}
 function createLocalViewSessionManifest(input) {
   return {
     layout: OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT,
     version: OPENSTEER_LOCAL_VIEW_SESSION_VERSION,
-    sessionId: buildLocalViewSessionId({
+    sessionId: buildLocalViewSessionIdForRecord({
       rootPath: input.rootPath,
-      pid: input.live.pid,
-      startedAt: input.live.startedAt
+      live: input.live
     }),
     rootPath: input.rootPath,
     ...input.workspace === void 0 ? {} : { workspace: input.workspace },
@@ -10363,6 +10459,7 @@ var OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT, OPENSTEER_LOCAL_VIEW_SESSION_VERSION;
 var init_session_manifest = __esm({
   "src/local-view/session-manifest.ts"() {
     init_filesystem2();
+    init_live_session();
     init_runtime_dir();
     OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT = "opensteer-local-view-session";
     OPENSTEER_LOCAL_VIEW_SESSION_VERSION = 1;
@@ -10531,6 +10628,7 @@ function toPersistedLocalBrowserSessionRecord(workspace, live) {
     version: 1,
     provider: "local",
     ...workspace === void 0 ? {} : { workspace },
+    ownership: live.ownership,
     engine: live.engine,
     ...live.endpoint === void 0 ? {} : { endpoint: live.endpoint },
     ...live.baseUrl === void 0 ? {} : { baseUrl: live.baseUrl },
@@ -10546,6 +10644,7 @@ function toPersistedLocalBrowserSessionRecord(workspace, live) {
 function toWorkspaceLiveBrowserRecord(record) {
   return {
     mode: "persistent",
+    ownership: getPersistedLocalBrowserSessionOwnership(record),
     engine: record.engine,
     ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
     ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
@@ -10572,7 +10671,12 @@ function isAttachBrowserOptions(browser) {
 async function resolveAttachEndpoint(browser) {
   const endpoint = browser?.endpoint?.trim();
   if (endpoint && endpoint.length > 0) {
-    return endpoint;
+    const inspected = await inspectCdpEndpoint({
+      endpoint,
+      ...browser?.headers === void 0 ? {} : { headers: browser.headers },
+      timeoutMs: DEFAULT_TIMEOUT_MS
+    });
+    return inspected.endpoint;
   }
   const selection = await selectAttachBrowserCandidate({
     timeoutMs: DEFAULT_TIMEOUT_MS
@@ -10998,7 +11102,7 @@ var init_browser_manager = __esm({
         }
         const liveRecord = await this.readLivePersistentBrowser(await this.ensureWorkspaceStore());
         return {
-          mode: this.mode,
+          mode: liveRecord?.ownership === "attached" ? "attach" : this.mode,
           engine: liveRecord?.engine ?? this.engineName,
           ...this.workspace === void 0 ? {} : { workspace: this.workspace },
           live: liveRecord !== void 0
@@ -11126,6 +11230,7 @@ var init_browser_manager = __esm({
           });
           const liveRecord = {
             mode: "persistent",
+            ownership: "owned",
             engine: "abp",
             baseUrl: launched.baseUrl,
             remoteDebuggingUrl: launched.remoteDebuggingUrl,
@@ -11212,11 +11317,78 @@ var init_browser_manager = __esm({
       }
       async createAttachEngine() {
         const endpoint = await resolveAttachEndpoint(this.browserOptions);
-        return this.createAttachedEngine({
-          endpoint,
-          ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
-          freshTab: this.browserOptions?.freshTab ?? true,
-          onDispose: async () => void 0
+        if (this.workspace === void 0) {
+          return this.createAttachedEngine({
+            endpoint,
+            ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+            freshTab: this.browserOptions?.freshTab ?? true,
+            onDispose: async () => void 0
+          });
+        }
+        const workspace = await this.ensureWorkspaceStore();
+        return workspace.lock(async () => {
+          const live = await this.readLivePersistentBrowser(workspace);
+          if (live) {
+            if (live.engine !== "playwright") {
+              throw new Error(
+                `workspace "${this.workspace}" already has a live ${live.engine} browser. Close it before attaching a Playwright browser.`
+              );
+            }
+            if (live.ownership !== "attached") {
+              throw new Error(
+                `workspace "${this.workspace}" already has a live Opensteer-owned browser. Close it before attaching another browser.`
+              );
+            }
+            if (live.endpoint === void 0) {
+              throw new Error("workspace live browser record is missing a DevTools endpoint.");
+            }
+            if (live.endpoint !== endpoint) {
+              throw new Error(
+                `workspace "${this.workspace}" is already attached to a different browser endpoint. Close it before reattaching.`
+              );
+            }
+            await bestEffortRegisterLocalViewSession({
+              rootPath: workspace.rootPath,
+              ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+              live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+              ownership: "attached"
+            });
+            return this.createAttachedEngine({
+              endpoint: live.endpoint,
+              ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+              freshTab: this.browserOptions?.freshTab ?? true,
+              onDispose: async () => void 0
+            });
+          }
+          const liveRecord = {
+            mode: "persistent",
+            ownership: "attached",
+            engine: "playwright",
+            endpoint,
+            pid: 0,
+            startedAt: Date.now(),
+            userDataDir: workspace.browserUserDataDir
+          };
+          await this.writeLivePersistentBrowser(workspace, liveRecord);
+          const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+          await bestEffortRegisterLocalViewSession({
+            rootPath: workspace.rootPath,
+            ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+            live: persistedLiveRecord,
+            ownership: "attached"
+          });
+          try {
+            return await this.createAttachedEngine({
+              endpoint,
+              ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+              freshTab: this.browserOptions?.freshTab ?? true,
+              onDispose: async () => void 0
+            });
+          } catch (error) {
+            await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
+            await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+            throw error;
+          }
         });
       }
       async createPersistentEngine() {
@@ -11236,7 +11408,7 @@ var init_browser_manager = __esm({
               rootPath: workspace.rootPath,
               ...this.workspace === void 0 ? {} : { workspace: this.workspace },
               live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
-              ownership: "owned"
+              ownership: live.ownership
             });
             return this.createAttachedEngine({
               endpoint: live.endpoint,
@@ -11252,6 +11424,7 @@ var init_browser_manager = __esm({
           });
           const liveRecord = {
             mode: "persistent",
+            ownership: "owned",
             engine: "playwright",
             endpoint: launched.endpoint,
             pid: launched.pid,
@@ -11381,7 +11554,20 @@ var init_browser_manager = __esm({
         if (live === void 0) {
           return void 0;
         }
+        if (live.ownership === "attached") {
+          const attachedRecord = toPersistedLocalBrowserSessionRecord(this.workspace, live);
+          if (!await isAttachedLocalBrowserSessionReachable(attachedRecord)) {
+            await this.unregisterLocalViewSessionForRecord(workspace.rootPath, attachedRecord);
+            await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+            return void 0;
+          }
+          return live;
+        }
         if (!isProcessRunning(live.pid)) {
+          await this.unregisterLocalViewSessionForRecord(
+            workspace.rootPath,
+            toPersistedLocalBrowserSessionRecord(this.workspace, live)
+          );
           await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
           return void 0;
         }
@@ -11429,6 +11615,10 @@ var init_browser_manager = __esm({
           workspace.rootPath,
           toPersistedLocalBrowserSessionRecord(this.workspace, live)
         );
+        if (live.ownership === "attached") {
+          await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+          return;
+        }
         if (live.engine === "playwright") {
           if (live.endpoint !== void 0) {
             await requestBrowserClose(live.endpoint).catch(() => void 0);
@@ -11457,10 +11647,18 @@ var init_browser_manager = __esm({
       }
       async unregisterLocalViewSessionForRecord(rootPath, record) {
         await bestEffortUnregisterLocalViewSession(
-          buildLocalViewSessionId({
+          getPersistedLocalBrowserSessionOwnership(record) === "attached" ? buildLocalViewSessionId({
+            rootPath,
+            startedAt: record.startedAt,
+            ownership: "attached",
+            ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
+            ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
+            ...record.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: record.remoteDebuggingUrl }
+          }) : buildLocalViewSessionId({
             rootPath,
-            pid: record.pid,
-            startedAt: record.startedAt
+            startedAt: record.startedAt,
+            ownership: "owned",
+            pid: record.pid
           })
         );
       }
@@ -11961,11 +12159,11 @@ function delay2(ms) {
 function wrapCloudFetchError(error, input) {
   if (!(error instanceof Error)) {
     return new Error(
-      `Failed to reach Opensteer cloud endpoint ${input.method} ${input.url}. Check OPENSTEER_BASE_URL and network reachability from this environment.`
+      `Failed to reach Opensteer cloud endpoint ${input.method} ${input.url}. Check the configured Opensteer cloud base URL and network reachability from this environment.`
     );
   }
   const wrapped = new Error(
-    `Failed to reach Opensteer cloud endpoint ${input.method} ${input.url}. Check OPENSTEER_BASE_URL and network reachability from this environment.`,
+    `Failed to reach Opensteer cloud endpoint ${input.method} ${input.url}. Check the configured Opensteer cloud base URL and network reachability from this environment.`,
     {
       cause: error
     }
@@ -12240,34 +12438,40 @@ function resolveCloudConfig(input = {}) {
     return void 0;
   }
   const cloudProvider = input.provider?.mode === "cloud" ? input.provider : void 0;
-  const apiKey = cloudProvider?.apiKey ?? input.environment?.OPENSTEER_API_KEY;
-  if (!apiKey || apiKey.trim().length === 0) {
+  const apiKey = normalizeOptionalCloudConfigValue(cloudProvider?.apiKey) ?? normalizeOptionalCloudConfigValue(input.environment?.OPENSTEER_API_KEY);
+  if (apiKey === void 0) {
     throw new Error("provider=cloud requires OPENSTEER_API_KEY or provider.apiKey.");
   }
-  const baseUrl = cloudProvider?.baseUrl ?? input.environment?.OPENSTEER_BASE_URL;
-  if (!baseUrl || baseUrl.trim().length === 0) {
-    throw new Error("provider=cloud requires OPENSTEER_BASE_URL or provider.baseUrl.");
-  }
-  const appBaseUrl = cloudProvider?.appBaseUrl ?? input.environment?.OPENSTEER_CLOUD_APP_BASE_URL;
+  const baseUrl = normalizeOptionalCloudConfigValue(cloudProvider?.baseUrl) ?? normalizeOptionalCloudConfigValue(input.environment?.OPENSTEER_BASE_URL) ?? DEFAULT_OPENSTEER_CLOUD_BASE_URL;
+  const appBaseUrl = normalizeOptionalCloudConfigValue(cloudProvider?.appBaseUrl) ?? normalizeOptionalCloudConfigValue(input.environment?.OPENSTEER_CLOUD_APP_BASE_URL);
   return {
-    apiKey: apiKey.trim(),
-    baseUrl: baseUrl.trim().replace(/\/+$/, ""),
-    ...appBaseUrl === void 0 || appBaseUrl.trim().length === 0 ? {} : { appBaseUrl: appBaseUrl.trim().replace(/\/+$/, "") },
+    apiKey,
+    baseUrl,
+    ...appBaseUrl === void 0 ? {} : { appBaseUrl },
     ...cloudProvider?.browserProfile === void 0 ? {} : { browserProfile: cloudProvider.browserProfile }
   };
 }
 function requireCloudAppBaseUrl(cloudConfig) {
-  const appBaseUrl = cloudConfig.appBaseUrl;
-  if (!appBaseUrl || appBaseUrl.trim().length === 0) {
+  const appBaseUrl = normalizeOptionalCloudConfigValue(cloudConfig.appBaseUrl);
+  if (appBaseUrl === void 0) {
     throw new Error(
       'record with provider=cloud requires OPENSTEER_CLOUD_APP_BASE_URL or "--cloud-app-base-url".'
     );
   }
-  return appBaseUrl.trim().replace(/\/+$/, "");
+  return appBaseUrl;
+}
+function normalizeOptionalCloudConfigValue(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().replace(/\/+$/, "");
+  return normalized.length === 0 ? void 0 : normalized;
 }
+var DEFAULT_OPENSTEER_CLOUD_BASE_URL;
 var init_config2 = __esm({
   "src/cloud/config.ts"() {
     init_config();
+    DEFAULT_OPENSTEER_CLOUD_BASE_URL = "https://api.opensteer.com";
   }
 });
 
@@ -12277,7 +12481,7 @@ var init_package = __esm({
   "../runtime-core/package.json"() {
     package_default2 = {
       name: "@opensteer/runtime-core",
-      version: "0.2.5",
+      version: "0.2.7",
       description: "Shared semantic runtime for Opensteer local and cloud execution.",
       license: "MIT",
       type: "module",
@@ -12459,14 +12663,14 @@ var init_defaults = __esm({
       snapshot: 0
     };
     DOM_ACTION_VISUAL_STABILITY_PROFILES = {
-      "dom.click": { settleMs: 750, scope: "visible-frames", timeoutMs: 7e3 },
-      "dom.input": { settleMs: 750, scope: "visible-frames", timeoutMs: 7e3 },
-      "dom.scroll": { settleMs: 600, scope: "visible-frames", timeoutMs: 7e3 },
+      "dom.click": { settleMs: 750, scope: "main-frame", timeoutMs: 7e3 },
+      "dom.input": { settleMs: 750, scope: "main-frame", timeoutMs: 7e3 },
+      "dom.scroll": { settleMs: 600, scope: "main-frame", timeoutMs: 7e3 },
       "dom.hover": { settleMs: 200, scope: "main-frame", timeoutMs: 2500 }
     };
     DEFAULT_DOM_ACTION_VISUAL_STABILITY_PROFILE = {
       settleMs: 750,
-      scope: "visible-frames",
+      scope: "main-frame",
       timeoutMs: 7e3
     };
     NAVIGATION_VISUAL_STABILITY_PROFILE = {
@@ -12490,6 +12694,7 @@ var init_defaults = __esm({
             pageRef: input.pageRef,
             timeoutMs: effectiveTimeout,
             settleMs: profile.settleMs,
+            ...input.observedMutationQuietMs === void 0 ? {} : { initialQuietMs: input.observedMutationQuietMs },
             scope: profile.scope
           });
           return true;
@@ -12510,15 +12715,20 @@ var init_defaults = __esm({
           return false;
         }
         try {
-          const startedAt = Date.now();
-          await input.engine.waitForPostLoadQuiet({
-            pageRef: input.pageRef,
-            timeoutMs: effectiveTimeout,
-            quietMs: DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS,
-            captureWindowMs: Math.min(NAVIGATION_POST_LOAD_CAPTURE_WINDOW_MS, effectiveTimeout),
-            signal: input.signal
-          });
-          const visualTimeout = Math.max(0, effectiveTimeout - (Date.now() - startedAt));
+          let visualTimeout = effectiveTimeout;
+          let initialQuietMs = input.observedMutationQuietMs ?? 0;
+          if (!input.postLoadHandled) {
+            const startedAt = Date.now();
+            await input.engine.waitForPostLoadQuiet({
+              pageRef: input.pageRef,
+              timeoutMs: effectiveTimeout,
+              quietMs: DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS,
+              captureWindowMs: Math.min(NAVIGATION_POST_LOAD_CAPTURE_WINDOW_MS, effectiveTimeout),
+              signal: input.signal
+            });
+            visualTimeout = Math.max(0, effectiveTimeout - (Date.now() - startedAt));
+            initialQuietMs = Math.max(initialQuietMs, DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS);
+          }
           if (visualTimeout <= 0) {
             return true;
           }
@@ -12526,6 +12736,7 @@ var init_defaults = __esm({
             pageRef: input.pageRef,
             timeoutMs: visualTimeout,
             settleMs: profile.settleMs,
+            ...initialQuietMs <= 0 ? {} : { initialQuietMs },
             scope: profile.scope
           });
           return true;
@@ -13141,7 +13352,9 @@ function resolveExtractedValueInContext(normalizedValue, options) {
 function stripPositionClauses(nodes) {
   return (nodes || []).map((node) => ({
     ...node,
-    match: (node.match || []).filter((clause) => clause.kind !== "position" && clause.kind !== "text")
+    match: (node.match || []).filter(
+      (clause) => clause.kind !== "position" && clause.kind !== "text"
+    )
   }));
 }
 function dedupeSelectors(selectors) {
@@ -14693,7 +14906,7 @@ var init_executor = __esm({
             ...snapshot === void 0 ? {} : { snapshot },
             signal: timeout.signal,
             remainingMs: () => timeout.remainingMs(),
-            policySettle: async (targetPageRef, trigger) => {
+            policySettle: async (targetPageRef, trigger, boundary2) => {
               try {
                 await settleWithPolicy(this.options.policy.settle, {
                   operation,
@@ -14701,7 +14914,9 @@ var init_executor = __esm({
                   engine: this.options.engine,
                   pageRef: targetPageRef,
                   signal: timeout.signal,
-                  remainingMs: timeout.remainingMs()
+                  remainingMs: timeout.remainingMs(),
+                  ...boundary2?.observedMutationQuietMs === void 0 ? {} : { observedMutationQuietMs: boundary2.observedMutationQuietMs },
+                  ...boundary2?.postLoadHandled === true ? { postLoadHandled: true } : {}
                 });
               } catch (error) {
                 if (snapshot !== void 0 && isSoftSettleTimeoutError(error, timeout.signal)) {
@@ -15448,7 +15663,9 @@ var init_runtime = __esm({
             `Unable to resolve structural anchor "${buildPathSelectorHint(anchor)}" in the current session`
           );
         }
-        const replayPath = await this.tryBuildPathFromNode(context.snapshot, target.node, { enableTextMatch: true });
+        const replayPath = await this.tryBuildPathFromNode(context.snapshot, target.node, {
+          enableTextMatch: true
+        });
         return this.createResolvedTarget(source, context.snapshot, target.node, anchor, {
           ...persist === void 0 ? {} : { persist },
           ...replayPath === void 0 ? {} : { replayPath }
@@ -15959,12 +16176,16 @@ function toOpensteerResolvedTarget(target) {
     documentRef: target.documentRef,
     documentEpoch: target.documentEpoch,
     nodeRef: target.nodeRef,
-    tagName: target.node.nodeName.toUpperCase(),
+    tagName: toOpensteerTagName(target.node.nodeName),
     pathHint: buildPathSelectorHint(target.replayPath ?? target.anchor),
     ...target.persist === void 0 ? {} : { persist: target.persist },
     ...target.selectorUsed === void 0 ? {} : { selectorUsed: target.selectorUsed }
   };
 }
+function toOpensteerTagName(nodeName) {
+  const tagName = String(nodeName).trim().toLowerCase();
+  return tagName.length === 0 ? "element" : tagName;
+}
 var init_trace_enrichment = __esm({
   "../runtime-core/src/runtimes/computer-use/trace-enrichment.ts"() {
     init_src();
@@ -16020,7 +16241,7 @@ var init_runtime2 = __esm({
             screenshot,
             signal: input.timeout.signal,
             remainingMs: () => input.timeout.remainingMs(),
-            policySettle: async (pageRef, trigger) => {
+            policySettle: async (pageRef, trigger, boundary) => {
               try {
                 await settleWithPolicy(this.options.policy.settle, {
                   operation: "computer.execute",
@@ -16028,7 +16249,9 @@ var init_runtime2 = __esm({
                   engine: this.options.engine,
                   pageRef,
                   signal: input.timeout.signal,
-                  remainingMs: input.timeout.remainingMs()
+                  remainingMs: input.timeout.remainingMs(),
+                  ...boundary?.observedMutationQuietMs === void 0 ? {} : { observedMutationQuietMs: boundary.observedMutationQuietMs },
+                  ...boundary?.postLoadHandled === true ? { postLoadHandled: true } : {}
                 });
               } catch (error) {
                 if (pageRef === input.pageRef && isSoftSettleTimeoutError(error, input.timeout.signal)) {
@@ -17024,29 +17247,29 @@ function buildVariantDescriptorFromCluster(descriptors) {
   const keyStats = /* @__PURE__ */ new Map();
   for (const descriptor of descriptors) {
     for (const field of descriptor.fields) {
-      const stat2 = keyStats.get(field.path) ?? {
+      const stat3 = keyStats.get(field.path) ?? {
         indices: /* @__PURE__ */ new Set(),
         pathNodes: [],
         attributes: [],
         sources: []
       };
-      stat2.indices.add(descriptor.index);
+      stat3.indices.add(descriptor.index);
       if (isPersistedOpensteerExtractionValueNode(field.node)) {
-        stat2.pathNodes.push(field.node.$path);
-        stat2.attributes.push(field.node.attribute);
+        stat3.pathNodes.push(field.node.$path);
+        stat3.attributes.push(field.node.attribute);
       } else if (isPersistedOpensteerExtractionSourceNode(field.node)) {
-        stat2.sources.push("current_url");
+        stat3.sources.push("current_url");
       }
-      keyStats.set(field.path, stat2);
+      keyStats.set(field.path, stat3);
     }
   }
   const mergedFields = [];
-  for (const [fieldPath, stat2] of keyStats) {
-    if (stat2.indices.size < threshold) {
+  for (const [fieldPath, stat3] of keyStats) {
+    if (stat3.indices.size < threshold) {
       continue;
     }
-    if (stat2.pathNodes.length >= threshold) {
-      let mergedFieldPath = stat2.pathNodes.length === 1 ? sanitizeElementPath(stat2.pathNodes[0]) : mergeElementPathsByMajority(stat2.pathNodes);
+    if (stat3.pathNodes.length >= threshold) {
+      let mergedFieldPath = stat3.pathNodes.length === 1 ? sanitizeElementPath(stat3.pathNodes[0]) : mergeElementPathsByMajority(stat3.pathNodes);
       if (!mergedFieldPath) {
         continue;
       }
@@ -17054,8 +17277,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
         mergedFieldPath = relaxPathForSingleSample(mergedFieldPath, "field");
       }
       mergedFieldPath = minimizePathMatchClauses(mergedFieldPath, "field");
-      const attrThreshold = stat2.pathNodes.length === 1 ? 1 : majorityThreshold(stat2.pathNodes.length);
-      const attribute = pickModeString(stat2.attributes, attrThreshold);
+      const attrThreshold = stat3.pathNodes.length === 1 ? 1 : majorityThreshold(stat3.pathNodes.length);
+      const attribute = pickModeString(stat3.attributes, attrThreshold);
       mergedFields.push({
         path: fieldPath,
         node: createValueNode({
@@ -17065,7 +17288,7 @@ function buildVariantDescriptorFromCluster(descriptors) {
       });
       continue;
     }
-    const dominantSource = pickModeString(stat2.sources, threshold);
+    const dominantSource = pickModeString(stat3.sources, threshold);
     if (dominantSource === "current_url") {
       mergedFields.push({
         path: fieldPath,
@@ -19173,28 +19396,24 @@ function restoreBoundedAttr(el, attr, value) {
   }
   setBoundedAttr(el, attr, value);
 }
-function deduplicateImages(html) {
+function deduplicateImagesInDom($) {
   const seen = /* @__PURE__ */ new Set();
-  return html.replace(/<img\b([^>]*)>/gi, (full, attrContent) => {
-    if (/\bc\s*=/.test(attrContent)) {
-      return full;
-    }
-    const srcMatch = attrContent.match(/\bsrc\s*=\s*(["']?)(.*?)\1/);
-    const srcsetMatch = attrContent.match(/\bsrcset\s*=\s*(["'])(.*?)\1/);
-    let src = null;
-    if (srcMatch && srcMatch[2]) {
-      src = srcMatch[2].trim();
-    } else if (srcsetMatch && srcsetMatch[2]) {
-      src = srcsetMatch[2].split(",")[0]?.trim().split(" ")[0] ?? null;
+  $("img").each(function deduplicateDomImage() {
+    const el = $(this);
+    if (el.attr("c") !== void 0) {
+      return;
     }
+    const srcValue = el.attr("src")?.trim();
+    const srcsetValue = el.attr("srcset");
+    const src = srcValue && srcValue.length > 0 ? srcValue : srcsetValue?.split(",")[0]?.trim().split(/\s+/u)[0];
     if (!src) {
-      return full;
+      return;
     }
     if (seen.has(src)) {
-      return "";
+      el.remove();
+      return;
     }
     seen.add(src);
-    return full;
   });
 }
 function hasAttribute2(node, attr) {
@@ -19252,23 +19471,6 @@ function isPreservedImageElement(node) {
 function getElementsInReverseDocumentOrder($) {
   return $.root().find("*").toArray().reverse().filter((node) => node.type === "tag");
 }
-function getNodeDepth(node) {
-  let depth = 0;
-  let current = node.parent;
-  while (current) {
-    depth++;
-    current = current.parent;
-  }
-  return depth;
-}
-function getElementsByDepthDescending($) {
-  const elements = $.root().find("*").toArray().filter((node) => node.type === "tag");
-  const depths = /* @__PURE__ */ new Map();
-  for (const el of elements) {
-    depths.set(el, getNodeDepth(el));
-  }
-  return elements.sort((a, b) => (depths.get(b) ?? 0) - (depths.get(a) ?? 0));
-}
 function flattenExtractionTree($) {
   for (const node of getElementsInReverseDocumentOrder($)) {
     const el = $(node);
@@ -19286,19 +19488,6 @@ function flattenExtractionTree($) {
     el.replaceWith(el.contents());
   }
 }
-function hasMarkedAncestor(el, attr) {
-  let current = el[0]?.parent;
-  while (current) {
-    if (!isElementLikeNode(current)) {
-      return false;
-    }
-    if (current.attribs?.[attr] !== void 0) {
-      return true;
-    }
-    current = current.parent;
-  }
-  return false;
-}
 function isIndicatorImage(node) {
   return (node?.tagName || "").toLowerCase() === "img" && (hasAttribute2(node, "alt") || hasAttribute2(node, "src") || hasAttribute2(node, "srcset"));
 }
@@ -19416,7 +19605,7 @@ function serializeForExtraction($, root) {
   traverse(root, 0);
   return lines.map((l) => l.trim()).filter((l) => l.length > 0).join("");
 }
-function isClickable($, el, context) {
+function isClickable(el, context) {
   if (context.hasPreMarked) {
     return el.attr(OPENSTEER_INTERACTIVE_ATTR) !== void 0;
   }
@@ -19450,21 +19639,17 @@ function isClickable($, el, context) {
   }
   return false;
 }
-function cleanForExtraction(html) {
+function prepareExtractionSnapshotDom(html) {
   if (!html.trim()) {
-    return "";
+    return void 0;
   }
   const $ = cheerio__namespace.load(html, { xmlMode: false });
   removeNoise($);
   removeComments($);
   markInlineSelfHiddenFallback($);
   pruneSelfHiddenNodes($);
-  const $clean = cheerio__namespace.load(
-    $.html().replace(/\n{2,}/g, "\n").trim(),
-    { xmlMode: false }
-  );
-  $clean("*").each(function stripAndRestoreExtractionAttrs() {
-    const el = $clean(this);
+  $("*").each(function stripAndRestoreExtractionAttrs() {
+    const el = $(this);
     const node = el[0];
     if (!node) {
       return;
@@ -19505,16 +19690,20 @@ function cleanForExtraction(html) {
       restoreBoundedAttr(el, "href", hrefValue);
     }
   });
-  flattenExtractionTree($clean);
-  const root = $clean.root()[0];
+  flattenExtractionTree($);
+  deduplicateImagesInDom($);
+  return $;
+}
+function serializePreparedExtractionSnapshot($) {
+  const root = $.root()[0];
   if (root === void 0) {
     return "";
   }
-  return deduplicateImages(serializeForExtraction($clean, root));
+  return serializeForExtraction($, root);
 }
-function cleanForAction(html) {
+function prepareActionSnapshotDom(html) {
   if (!html.trim()) {
-    return "";
+    return void 0;
   }
   const $ = cheerio__namespace.load(html, { xmlMode: false });
   removeNoise($);
@@ -19523,13 +19712,12 @@ function cleanForAction(html) {
   pruneSelfHiddenNodes($);
   const clickableMark = "data-clickable-marker";
   const indicatorMark = "data-keep-indicator";
-  const branchMark = "data-keep-branch";
   const context = {
     hasPreMarked: $(`[${OPENSTEER_INTERACTIVE_ATTR}]`).length > 0
   };
   $("*").each(function markClickables() {
     const el = $(this);
-    if (isClickable($, el, context)) {
+    if (isClickable(el, context)) {
       el.attr(clickableMark, "1");
     }
   });
@@ -19559,25 +19747,7 @@ function cleanForAction(html) {
       el.remove();
     }
   });
-  $(`[${clickableMark}], [${indicatorMark}]`).each(function markBranches() {
-    let current = $(this).parent();
-    while (current.length > 0) {
-      const node = current[0];
-      if (!node || node.type !== "tag") {
-        break;
-      }
-      const ancestor = current;
-      const tag = (node.tagName || "").toLowerCase();
-      if (ROOT_TAGS.has(tag) || ancestor.attr(clickableMark) !== void 0) {
-        break;
-      }
-      if (!isBoundaryTag(tag)) {
-        ancestor.attr(branchMark, "1");
-      }
-      current = ancestor.parent();
-    }
-  });
-  for (const node of getElementsByDepthDescending($)) {
+  for (const node of getElementsInReverseDocumentOrder($)) {
     const el = $(node);
     const tag = (node.tagName || "").toLowerCase();
     if (ROOT_TAGS.has(tag) || isBoundaryTag(tag)) {
@@ -19586,17 +19756,7 @@ function cleanForAction(html) {
     if (el.attr(clickableMark) !== void 0 || el.attr(indicatorMark) !== void 0) {
       continue;
     }
-    const insideClickable = hasMarkedAncestor(el, clickableMark);
-    const preserveBranch = el.attr(branchMark) !== void 0;
     const hasContent = hasElementChildren(node) || hasDirectText(node);
-    if (insideClickable || preserveBranch) {
-      if (!hasContent) {
-        el.remove();
-      } else {
-        unwrapActionNode($, el);
-      }
-      continue;
-    }
     if (!hasContent) {
       el.remove();
       continue;
@@ -19697,13 +19857,20 @@ function cleanForAction(html) {
     }
     el.removeAttr(clickableMark);
     el.removeAttr(indicatorMark);
-    el.removeAttr(branchMark);
     el.removeAttr(OPENSTEER_INTERACTIVE_ATTR);
     el.removeAttr(OPENSTEER_HIDDEN_ATTR);
     el.removeAttr(OPENSTEER_SCROLLABLE_ATTR);
     el.removeAttr(OPENSTEER_SELF_HIDDEN_ATTR);
   });
-  return compactHtml(deduplicateImages($.html()));
+  deduplicateImagesInDom($);
+  return $;
+}
+function serializePreparedActionSnapshot($) {
+  const normalized = compactHtml($.html());
+  if (normalized.length === 0) {
+    return "";
+  }
+  return cheerio__namespace.load(normalized, { xmlMode: false }).html();
 }
 var STRIP_TAGS, TEXT_ATTR_MAX, SRCSET_ATTR_MAX, MIDDLE_TRUNCATED_URL_ATTRS, TEXT_ATTRS, TRUNCATION_SUFFIX, MIDDLE_TRUNCATION_MARKER, MIDDLE_TRUNCATION_HEAD_MAX, MIDDLE_TRUNCATION_TAIL_MAX, SRCSET_CANDIDATE_HEAD_MAX, SRCSET_CANDIDATE_TAIL_MAX, SRCSET_COMPACT_CANDIDATE_HEAD_MAX, SRCSET_COMPACT_CANDIDATE_TAIL_MAX, SRCSET_FALLBACK_HEAD_MAX, SRCSET_FALLBACK_TAIL_MAX, NOISE_SELECTORS, VOID_TAGS2;
 var init_cleaner = __esm({
@@ -19764,23 +19931,27 @@ async function markLiveSnapshotSemantics(options) {
   const frames = await options.engine.listFrames({
     pageRef: options.pageRef
   });
-  for (const frame of frames) {
-    await evaluateFrameBestEffort(
-      options.engine,
-      frame.frameRef,
-      MARK_SNAPSHOT_SEMANTICS_SCRIPT,
-      SNAPSHOT_SEMANTIC_ARGS
-    );
-  }
-  return async () => {
-    for (const frame of frames) {
-      await evaluateFrameBestEffort(
+  await Promise.all(
+    frames.map(
+      (frame) => evaluateFrameBestEffort(
         options.engine,
         frame.frameRef,
-        CLEAR_SNAPSHOT_SEMANTICS_SCRIPT,
-        CLEAR_SNAPSHOT_SEMANTIC_ARGS
-      );
-    }
+        MARK_SNAPSHOT_SEMANTICS_SCRIPT,
+        SNAPSHOT_SEMANTIC_ARGS
+      )
+    )
+  );
+  return async () => {
+    await Promise.all(
+      frames.map(
+        (frame) => evaluateFrameBestEffort(
+          options.engine,
+          frame.frameRef,
+          CLEAR_SNAPSHOT_SEMANTICS_SCRIPT,
+          CLEAR_SNAPSHOT_SEMANTIC_ARGS
+        )
+      )
+    );
   };
 }
 var MARK_SNAPSHOT_SEMANTICS_SCRIPT, CLEAR_SNAPSHOT_SEMANTICS_SCRIPT, SNAPSHOT_SEMANTIC_ARGS, CLEAR_SNAPSHOT_SEMANTIC_ARGS;
@@ -19978,6 +20149,8 @@ var init_marking = __esm({
     ];
   }
 });
+
+// ../runtime-core/src/sdk/snapshot/compiler.ts
 function isLiveCounterSyncError(error) {
   return error instanceof LiveCounterSyncError;
 }
@@ -20015,20 +20188,22 @@ function ensureSparseCountersForAllRecords(counterRecords) {
 async function clearOpensteerLiveCounters(engine, pageRef) {
   const frames = await engine.listFrames({ pageRef });
   const failures = [];
-  for (const frame of frames) {
-    try {
-      await engine.evaluateFrame({
-        frameRef: frame.frameRef,
-        script: CLEAR_LIVE_COUNTERS_SCRIPT,
-        args: [{ sparseCounterAttr: OPENSTEER_SPARSE_COUNTER_ATTR }]
-      });
-    } catch (error) {
-      if (isDetachedFrameSyncError(error)) {
-        continue;
+  await Promise.all(
+    frames.map(async (frame) => {
+      try {
+        await engine.evaluateFrame({
+          frameRef: frame.frameRef,
+          script: CLEAR_LIVE_COUNTERS_SCRIPT,
+          args: [{ sparseCounterAttr: OPENSTEER_SPARSE_COUNTER_ATTR }]
+        });
+      } catch (error) {
+        if (isDetachedFrameSyncError(error)) {
+          return;
+        }
+        failures.push(`frame ${frame.frameRef} could not be cleared (${describeError(error)}).`);
       }
-      failures.push(`frame ${frame.frameRef} could not be cleared (${describeError(error)}).`);
-    }
-  }
+    })
+  );
   if (failures.length > 0) {
     throw buildLiveCounterSyncError("clear live counters", failures);
   }
@@ -20077,25 +20252,29 @@ async function syncDenseCountersToLiveDom(engine, pageRef, sparseToDirectMapping
       denseCounter
     ])
   );
-  for (const frame of frames) {
-    try {
-      await engine.evaluateFrame({
-        frameRef: frame.frameRef,
-        script: APPLY_DENSE_COUNTERS_SCRIPT,
-        args: [
-          {
-            sparseCounterAttr: OPENSTEER_SPARSE_COUNTER_ATTR,
-            mapping: mappingObj
-          }
-        ]
-      });
-    } catch (error) {
-      if (isDetachedFrameSyncError(error)) {
-        continue;
+  await Promise.all(
+    frames.map(async (frame) => {
+      try {
+        await engine.evaluateFrame({
+          frameRef: frame.frameRef,
+          script: APPLY_DENSE_COUNTERS_SCRIPT,
+          args: [
+            {
+              sparseCounterAttr: OPENSTEER_SPARSE_COUNTER_ATTR,
+              mapping: mappingObj
+            }
+          ]
+        });
+      } catch (error) {
+        if (isDetachedFrameSyncError(error)) {
+          return;
+        }
+        failures.push(
+          `frame ${frame.frameRef} could not be synchronized (${describeError(error)}).`
+        );
       }
-      failures.push(`frame ${frame.frameRef} could not be synchronized (${describeError(error)}).`);
-    }
-  }
+    })
+  );
   if (failures.length > 0) {
     throw buildLiveCounterSyncError("synchronize dense counters", failures);
   }
@@ -20113,26 +20292,26 @@ async function compileOpensteerSnapshot(options) {
       await clearOpensteerLiveCounters(options.engine, options.pageRef);
       await assignSparseCountersToLiveDom(options.engine, options.pageRef);
       const pageInfo = await options.engine.getPageInfo({ pageRef: options.pageRef });
-      const mainSnapshot = await getMainDocumentSnapshot(options.engine, options.pageRef);
-      const snapshotsByDocumentRef = await collectDocumentSnapshots(options.engine, mainSnapshot);
+      const { mainSnapshot, snapshotsByDocumentRef } = await getPageDocumentSnapshots(
+        options.engine,
+        options.pageRef
+      );
       await cleanupLiveSemantics();
       cleanupLiveSemantics = async () => {
       };
-      const snapshotIndices = /* @__PURE__ */ new Map();
       const renderedNodes = /* @__PURE__ */ new Map();
       const rawHtml = renderDocumentSnapshot(
         mainSnapshot.documentRef,
         snapshotsByDocumentRef,
-        snapshotIndices,
         renderedNodes,
         {
           iframeDepth: 0,
           shadowDepth: 0
         }
       );
-      const cleanedHtml = options.mode === "extraction" ? cleanForExtraction(rawHtml) : cleanForAction(rawHtml);
-      const compiledHtml = assignCounters(cleanedHtml, renderedNodes);
-      const finalHtml = options.mode === "extraction" ? unwrapExtractionHtml(compiledHtml.html) : compiledHtml.html;
+      const preparedSnapshotDom = options.mode === "extraction" ? prepareExtractionSnapshotDom(rawHtml) : prepareActionSnapshotDom(rawHtml);
+      const compiledHtml = assignCountersInDom(preparedSnapshotDom, renderedNodes, options.mode);
+      const finalHtml = preparedSnapshotDom === void 0 ? "" : options.mode === "extraction" ? serializePreparedExtractionSnapshot(preparedSnapshotDom) : serializePreparedActionSnapshot(preparedSnapshotDom);
       ensureSparseCountersForAllRecords(compiledHtml.counterRecords);
       await syncDenseCountersToLiveDom(
         options.engine,
@@ -20167,6 +20346,25 @@ async function getMainDocumentSnapshot(engine, pageRef) {
   }
   return engine.getDomSnapshot({ frameRef: mainFrame.frameRef });
 }
+async function getPageDocumentSnapshots(engine, pageRef) {
+  const bundleEngine = engine;
+  const bundledSnapshots = await bundleEngine.getPageDomSnapshots?.({ pageRef });
+  if (bundledSnapshots && bundledSnapshots.length > 0) {
+    const mainSnapshot2 = bundledSnapshots.find((snapshot) => snapshot.parentDocumentRef === void 0) ?? bundledSnapshots[0];
+    return {
+      mainSnapshot: mainSnapshot2,
+      snapshotsByDocumentRef: new Map(
+        bundledSnapshots.map((snapshot) => [snapshot.documentRef, snapshot])
+      )
+    };
+  }
+  const mainSnapshot = await getMainDocumentSnapshot(engine, pageRef);
+  const snapshotsByDocumentRef = await collectDocumentSnapshots(engine, mainSnapshot);
+  return {
+    mainSnapshot,
+    snapshotsByDocumentRef
+  };
+}
 async function collectDocumentSnapshots(engine, mainSnapshot) {
   const snapshotsByDocumentRef = /* @__PURE__ */ new Map([
     [mainSnapshot.documentRef, mainSnapshot]
@@ -20185,7 +20383,7 @@ async function collectDocumentSnapshots(engine, mainSnapshot) {
   }
   return snapshotsByDocumentRef;
 }
-function renderDocumentSnapshot(documentRef, snapshotsByDocumentRef, snapshotIndices, renderedNodes, depth) {
+function renderDocumentSnapshot(documentRef, snapshotsByDocumentRef, renderedNodes, depth) {
   const snapshot = snapshotsByDocumentRef.get(documentRef);
   if (!snapshot) {
     return "";
@@ -20197,17 +20395,9 @@ function renderDocumentSnapshot(documentRef, snapshotsByDocumentRef, snapshotInd
       `snapshot ${snapshot.documentRef} is missing root node ${String(snapshot.rootSnapshotNodeId)}`
     );
   }
-  return renderNode(
-    snapshot,
-    rootNode,
-    nodesById,
-    snapshotsByDocumentRef,
-    snapshotIndices,
-    renderedNodes,
-    depth
-  );
+  return renderNode(snapshot, rootNode, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
 }
-function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotIndices, renderedNodes, depth) {
+function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth) {
   if (node.nodeType === 3) {
     return escapeHtml(node.nodeValue || node.textContent || "");
   }
@@ -20215,56 +20405,26 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
     return "";
   }
   if (node.nodeType === 9 || node.nodeType === 11) {
-    return renderChildren(
-      snapshot,
-      node,
-      nodesById,
-      snapshotsByDocumentRef,
-      snapshotIndices,
-      renderedNodes,
-      depth
-    );
+    return renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
   }
   if (node.nodeType !== 1) {
-    return renderChildren(
-      snapshot,
-      node,
-      nodesById,
-      snapshotsByDocumentRef,
-      snapshotIndices,
-      renderedNodes,
-      depth
-    );
+    return renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
   }
   const tagName = normalizeTagName(node.nodeName);
   if (isPseudoElementTagName(tagName)) {
-    return renderChildren(
-      snapshot,
-      node,
-      nodesById,
-      snapshotsByDocumentRef,
-      snapshotIndices,
-      renderedNodes,
-      depth
-    );
+    return renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
   }
   if ((depth.iframeDepth > 0 || depth.shadowDepth > 0) && (tagName === "html" || tagName === "head" || tagName === "body")) {
-    return renderChildren(
-      snapshot,
-      node,
-      nodesById,
-      snapshotsByDocumentRef,
-      snapshotIndices,
-      renderedNodes,
-      depth
-    );
+    return renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
   }
   const snapshotAttributes = normalizeNodeAttributes(node.attributes);
+  const snapshotAttributeIndex = indexNodeAttributes(snapshotAttributes);
   const authoredAttributes = stripInternalSnapshotAttributes(snapshotAttributes);
+  const authoredAttributeIndex = indexNodeAttributes(authoredAttributes);
   const attributes = [...authoredAttributes];
-  const subtreeHidden = hasAttribute3(snapshotAttributes, OPENSTEER_HIDDEN_ATTR) || isLikelySubtreeHidden(node);
-  const selfHidden = !subtreeHidden && (hasAttribute3(snapshotAttributes, OPENSTEER_SELF_HIDDEN_ATTR) || isLikelySelfHidden(node, nodesById));
-  const interactive = !subtreeHidden && !selfHidden && (hasAttribute3(snapshotAttributes, OPENSTEER_INTERACTIVE_ATTR) || isLikelyInteractive(tagName, node, authoredAttributes));
+  const subtreeHidden = snapshotAttributeIndex.has(OPENSTEER_HIDDEN_ATTR) || isLikelySubtreeHidden(node);
+  const selfHidden = !subtreeHidden && (snapshotAttributeIndex.has(OPENSTEER_SELF_HIDDEN_ATTR) || isLikelySelfHidden(node, nodesById));
+  const interactive = !subtreeHidden && !selfHidden && (snapshotAttributeIndex.has(OPENSTEER_INTERACTIVE_ATTR) || isLikelyInteractive(tagName, node, authoredAttributes, authoredAttributeIndex));
   if (interactive) {
     attributes.push({ name: OPENSTEER_INTERACTIVE_ATTR, value: "1" });
   }
@@ -20273,7 +20433,7 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
   } else if (selfHidden) {
     attributes.push({ name: OPENSTEER_SELF_HIDDEN_ATTR, value: "1" });
   }
-  const sparseCounter = findAttributeValue(snapshotAttributes, OPENSTEER_SPARSE_COUNTER_ATTR);
+  const sparseCounter = snapshotAttributeIndex.get(OPENSTEER_SPARSE_COUNTER_ATTR);
   if (sparseCounter !== void 0) {
     attributes.push({ name: OPENSTEER_SPARSE_COUNTER_ATTR, value: sparseCounter });
   }
@@ -20284,21 +20444,18 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
     const syntheticNodeId = buildSyntheticNodeId(snapshot, node);
     attributes.push({ name: OPENSTEER_NODE_ID_ATTR, value: syntheticNodeId });
     renderedNodes.set(syntheticNodeId, {
-      locator: createNodeLocator(snapshot.documentRef, snapshot.documentEpoch, node.nodeRef),
-      anchor: buildSnapshotElementAnchor(snapshot, node, snapshotsByDocumentRef, snapshotIndices),
       pageRef: snapshot.pageRef,
       frameRef: snapshot.frameRef,
       documentRef: snapshot.documentRef,
       documentEpoch: snapshot.documentEpoch,
       nodeRef: node.nodeRef,
       tagName: tagName.toUpperCase(),
-      pathHint: buildPathHint(tagName, authoredAttributes),
-      ...buildTextSnippet(node.textContent) === void 0 ? {} : { text: buildTextSnippet(node.textContent) },
       ...authoredAttributes.length === 0 ? {} : { attributes: authoredAttributes },
       iframeDepth: depth.iframeDepth,
       shadowDepth: depth.shadowDepth,
       interactive,
-      liveCounterSyncEligible: isLiveCounterSyncEligible(node, nodesById)
+      liveCounterSyncEligible: isLiveCounterSyncEligible(node, nodesById),
+      ...node.textContent === void 0 ? {} : { textContent: node.textContent }
     });
   }
   const attributeText = attributesToHtml(attributes);
@@ -20307,7 +20464,6 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
     node,
     nodesById,
     snapshotsByDocumentRef,
-    snapshotIndices,
     renderedNodes,
     depth
   );
@@ -20318,7 +20474,6 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
   const iframeHtml = renderDocumentSnapshot(
     node.contentDocumentRef,
     snapshotsByDocumentRef,
-    snapshotIndices,
     renderedNodes,
     {
       iframeDepth: depth.iframeDepth + 1,
@@ -20330,7 +20485,7 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
   }
   return `${elementHtml}<${OPENSTEER_IFRAME_BOUNDARY_TAG} ${OPENSTEER_BOUNDARY_ATTR}="iframe">${iframeHtml}</${OPENSTEER_IFRAME_BOUNDARY_TAG}>`;
 }
-function renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotIndices, renderedNodes, depth) {
+function renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth) {
   const regularChildren = [];
   const shadowChildren = [];
   for (const childSnapshotNodeId of node.childSnapshotNodeIds) {
@@ -20347,18 +20502,10 @@ function renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, snaps
   const chunks = [];
   if (shadowChildren.length > 0) {
     const shadowHtml = shadowChildren.map(
-      (child) => renderNode(
-        snapshot,
-        child,
-        nodesById,
-        snapshotsByDocumentRef,
-        snapshotIndices,
-        renderedNodes,
-        {
-          iframeDepth: depth.iframeDepth,
-          shadowDepth: depth.shadowDepth + 1
-        }
-      )
+      (child) => renderNode(snapshot, child, nodesById, snapshotsByDocumentRef, renderedNodes, {
+        iframeDepth: depth.iframeDepth,
+        shadowDepth: depth.shadowDepth + 1
+      })
     ).join("");
     chunks.push(
       `<${OPENSTEER_SHADOW_BOUNDARY_TAG} ${OPENSTEER_BOUNDARY_ATTR}="shadow">${shadowHtml}</${OPENSTEER_SHADOW_BOUNDARY_TAG}>`
@@ -20366,24 +20513,21 @@ function renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, snaps
   }
   for (const child of regularChildren) {
     chunks.push(
-      renderNode(
-        snapshot,
-        child,
-        nodesById,
-        snapshotsByDocumentRef,
-        snapshotIndices,
-        renderedNodes,
-        depth
-      )
+      renderNode(snapshot, child, nodesById, snapshotsByDocumentRef, renderedNodes, depth)
     );
   }
   return chunks.join("");
 }
-function assignCounters(cleanedHtml, renderedNodes) {
-  const $ = cheerio__namespace.load(cleanedHtml, { xmlMode: false });
+function assignCountersInDom($, renderedNodes, mode) {
   const counterRecords = /* @__PURE__ */ new Map();
   const sparseToDirectMapping = /* @__PURE__ */ new Map();
   let nextCounter = 1;
+  if (!$) {
+    return {
+      counterRecords,
+      sparseToDirectMapping
+    };
+  }
   $("*").each(function assignElementCounter() {
     const el = $(this);
     const syntheticNodeId = el.attr(OPENSTEER_NODE_ID_ATTR);
@@ -20395,14 +20539,24 @@ function assignCounters(cleanedHtml, renderedNodes) {
     if (!rendered) {
       return;
     }
+    if (mode === "extraction" && EXTRACTION_SKIPPED_COUNTER_TAGS.has(rendered.tagName.toLowerCase())) {
+      el.removeAttr(OPENSTEER_SPARSE_COUNTER_ATTR);
+      return;
+    }
     const rawSparseCounter = el.attr(OPENSTEER_SPARSE_COUNTER_ATTR);
     el.removeAttr(OPENSTEER_SPARSE_COUNTER_ATTR);
     const sparseCounter = rawSparseCounter ? Number.parseInt(rawSparseCounter, 10) : void 0;
+    const replayableSparseCounter = typeof sparseCounter === "number" && Number.isFinite(sparseCounter) ? sparseCounter : void 0;
+    if (rendered.liveCounterSyncEligible && replayableSparseCounter === void 0) {
+      return;
+    }
     const counter = nextCounter++;
     el.attr("c", String(counter));
-    if (sparseCounter !== void 0 && Number.isFinite(sparseCounter)) {
-      sparseToDirectMapping.set(sparseCounter, counter);
+    if (replayableSparseCounter !== void 0) {
+      sparseToDirectMapping.set(replayableSparseCounter, counter);
     }
+    const pathHint = buildPathHint(rendered.tagName.toLowerCase(), rendered.attributes ?? []);
+    const text = buildTextSnippet(rendered.textContent);
     counterRecords.set(counter, {
       element: counter,
       pageRef: rendered.pageRef,
@@ -20411,20 +20565,17 @@ function assignCounters(cleanedHtml, renderedNodes) {
       documentEpoch: rendered.documentEpoch,
       nodeRef: rendered.nodeRef,
       tagName: rendered.tagName,
-      pathHint: rendered.pathHint,
-      ...rendered.text === void 0 ? {} : { text: rendered.text },
+      pathHint,
+      ...text === void 0 ? {} : { text },
       ...rendered.attributes === void 0 ? {} : { attributes: rendered.attributes },
       iframeDepth: rendered.iframeDepth,
       shadowDepth: rendered.shadowDepth,
       interactive: rendered.interactive,
       liveCounterSyncEligible: rendered.liveCounterSyncEligible,
-      locator: rendered.locator,
-      anchor: rendered.anchor,
-      ...sparseCounter !== void 0 && Number.isFinite(sparseCounter) ? { sparseCounter } : {}
+      ...replayableSparseCounter === void 0 ? {} : { sparseCounter: replayableSparseCounter }
     });
   });
   return {
-    html: $.html(),
     counterRecords,
     sparseToDirectMapping
   };
@@ -20498,28 +20649,28 @@ function isLikelySelfHidden(node, nodesById) {
   }
   return !hasVisibleOutOfFlowChild(node, nodesById);
 }
-function isLikelyInteractive(tagName, node, attributes) {
+function isLikelyInteractive(tagName, node, attributes, attributeIndex) {
   if (NATIVE_INTERACTIVE_TAGS.has(tagName)) {
-    if (tagName === "input" && findAttributeValue(attributes, "type")?.toLowerCase() === "hidden") {
+    if (tagName === "input" && attributeIndex.get("type")?.toLowerCase() === "hidden") {
       return false;
     }
     if (tagName !== "a") {
       return true;
     }
   }
-  if (tagName === "a" && findAttributeValue(attributes, "href") !== void 0) {
+  if (tagName === "a" && attributeIndex.has("href")) {
     return true;
   }
-  if (findAttributeValue(attributes, "onclick") !== void 0 || findAttributeValue(attributes, "onmousedown") !== void 0 || findAttributeValue(attributes, "onmouseup") !== void 0 || findAttributeValue(attributes, "data-action") !== void 0 || findAttributeValue(attributes, "data-click") !== void 0 || findAttributeValue(attributes, "data-toggle") !== void 0) {
+  if (attributeIndex.has("onclick") || attributeIndex.has("onmousedown") || attributeIndex.has("onmouseup") || attributeIndex.has("data-action") || attributeIndex.has("data-click") || attributeIndex.has("data-toggle")) {
     return true;
   }
-  if (hasNonNegativeTabIndex(findAttributeValue(attributes, "tabindex"))) {
+  if (hasNonNegativeTabIndex(attributeIndex.get("tabindex"))) {
     return true;
   }
-  if (findAttributeValue(attributes, "contenteditable")?.toLowerCase() === "true") {
+  if (attributeIndex.get("contenteditable")?.toLowerCase() === "true") {
     return true;
   }
-  const role = findAttributeValue(attributes, "role")?.toLowerCase();
+  const role = attributeIndex.get("role")?.toLowerCase();
   return role !== void 0 && INTERACTIVE_ROLE_SET.has(role);
 }
 function hasVisibleOutOfFlowChild(node, nodesById) {
@@ -20582,14 +20733,6 @@ function parseOpacity(value) {
   const parsed = Number.parseFloat(value);
   return Number.isFinite(parsed) ? parsed : Number.NaN;
 }
-function hasAttribute3(attributes, name) {
-  const normalizedName = name.toLowerCase();
-  return attributes.some((attribute) => attribute.name.toLowerCase() === normalizedName);
-}
-function unwrapExtractionHtml(html) {
-  const $ = cheerio__namespace.load(html, { xmlMode: false });
-  return $("body").html()?.trim() || html;
-}
 function buildSyntheticNodeId(snapshot, node) {
   return `${snapshot.documentRef}:${String(snapshot.documentEpoch)}:${String(node.snapshotNodeId)}`;
 }
@@ -20636,6 +20779,13 @@ function findAttributeValue(attributes, name) {
   const normalizedName = name.toLowerCase();
   return attributes.find((attribute) => attribute.name.toLowerCase() === normalizedName)?.value;
 }
+function indexNodeAttributes(attributes) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const attribute of attributes) {
+    indexed.set(attribute.name.toLowerCase(), attribute.value);
+  }
+  return indexed;
+}
 function attributesToHtml(attributes) {
   if (attributes.length === 0) {
     return "";
@@ -20645,68 +20795,16 @@ function attributesToHtml(attributes) {
 function escapeAttribute(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function buildSnapshotElementAnchor(snapshot, node, snapshotsByDocumentRef, snapshotIndices) {
-  const index = getSnapshotIndex(snapshot.documentRef, snapshotsByDocumentRef, snapshotIndices);
-  const localAnchor = buildLocalStructuralElementAnchor(index, node);
-  return prefixIframeContext(snapshot, localAnchor, snapshotsByDocumentRef, snapshotIndices);
-}
-function prefixIframeContext(snapshot, localPath, snapshotsByDocumentRef, snapshotIndices) {
-  if (snapshot.parentDocumentRef === void 0) {
-    return sanitizeStructuralElementAnchor(localPath);
-  }
-  const parentSnapshot = snapshotsByDocumentRef.get(snapshot.parentDocumentRef);
-  if (!parentSnapshot) {
-    throw new Error(
-      `document ${snapshot.documentRef} has parent ${snapshot.parentDocumentRef} but no parent snapshot`
-    );
-  }
-  const parentIndex = getSnapshotIndex(
-    parentSnapshot.documentRef,
-    snapshotsByDocumentRef,
-    snapshotIndices
-  );
-  const iframeHost = findIframeHostNode(parentIndex, snapshot.documentRef);
-  if (!iframeHost) {
-    throw new Error(
-      `document ${snapshot.documentRef} has parent ${snapshot.parentDocumentRef} but no iframe host`
-    );
-  }
-  const hostPath = buildSnapshotElementAnchor(
-    parentSnapshot,
-    iframeHost,
-    snapshotsByDocumentRef,
-    snapshotIndices
-  );
-  return sanitizeStructuralElementAnchor({
-    context: [...hostPath.context, { kind: "iframe", host: hostPath.nodes }, ...localPath.context],
-    nodes: localPath.nodes
-  });
-}
-function getSnapshotIndex(documentRef, snapshotsByDocumentRef, snapshotIndices) {
-  const existing = snapshotIndices.get(documentRef);
-  if (existing) {
-    return existing;
-  }
-  const snapshot = snapshotsByDocumentRef.get(documentRef);
-  if (!snapshot) {
-    throw new Error(`missing DOM snapshot for ${documentRef}`);
-  }
-  const index = createSnapshotIndex(snapshot);
-  snapshotIndices.set(documentRef, index);
-  return index;
-}
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-var INTERNAL_SNAPSHOT_ATTRIBUTE_NAMES, MAX_LIVE_COUNTER_SYNC_ATTEMPTS, CLEAR_LIVE_COUNTERS_SCRIPT, ASSIGN_SPARSE_COUNTERS_SCRIPT, APPLY_DENSE_COUNTERS_SCRIPT, LiveCounterSyncError;
+var EXTRACTION_SKIPPED_COUNTER_TAGS, INTERNAL_SNAPSHOT_ATTRIBUTE_NAMES, MAX_LIVE_COUNTER_SYNC_ATTEMPTS, CLEAR_LIVE_COUNTERS_SCRIPT, ASSIGN_SPARSE_COUNTERS_SCRIPT, APPLY_DENSE_COUNTERS_SCRIPT, LiveCounterSyncError;
 var init_compiler = __esm({
   "../runtime-core/src/sdk/snapshot/compiler.ts"() {
-    init_src();
-    init_path();
-    init_selectors();
     init_cleaner();
     init_constants();
     init_marking();
+    EXTRACTION_SKIPPED_COUNTER_TAGS = /* @__PURE__ */ new Set(["html", "head", "body"]);
     INTERNAL_SNAPSHOT_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
       "c",
       OPENSTEER_BOUNDARY_ATTR,
@@ -20721,7 +20819,7 @@ var init_compiler = __esm({
     MAX_LIVE_COUNTER_SYNC_ATTEMPTS = 4;
     CLEAR_LIVE_COUNTERS_SCRIPT = `(({ sparseCounterAttr }) => {
   const walk = (root) => {
-    for (const child of root.children) {
+    for (const child of Array.from(root?.children || [])) {
       child.removeAttribute("c");
       child.removeAttribute(sparseCounterAttr);
       walk(child);
@@ -20737,7 +20835,7 @@ var init_compiler = __esm({
     ASSIGN_SPARSE_COUNTERS_SCRIPT = `(({ sparseCounterAttr, startCounter }) => {
   let counter = startCounter;
   const walk = (root) => {
-    for (const child of root.children) {
+    for (const child of Array.from(root?.children || [])) {
       child.setAttribute(sparseCounterAttr, String(counter++));
       walk(child);
       if (child.shadowRoot) {
@@ -20751,7 +20849,7 @@ var init_compiler = __esm({
 })`;
     APPLY_DENSE_COUNTERS_SCRIPT = `(({ sparseCounterAttr, mapping }) => {
   const walk = (root) => {
-    for (const child of root.children) {
+    for (const child of Array.from(root?.children || [])) {
       child.removeAttribute("c");
       const sparse = child.getAttribute(sparseCounterAttr);
       if (sparse !== null) {
@@ -22935,15 +23033,10 @@ function normalizeNamespace2(value) {
   const normalized = String(value ?? "default").trim();
   return normalized.length === 0 ? "default" : normalized;
 }
-function toOpensteerActionResult(result) {
+function toOpensteerActionResult(target) {
   return {
-    target: toOpensteerResolvedTarget2(result.resolved),
-    ...result.point === void 0 ? {} : {
-      point: {
-        x: result.point.x,
-        y: result.point.y
-      }
-    }
+    tagName: toOpensteerTagName2(target.node.nodeName),
+    ...target.persist === void 0 ? {} : { persist: target.persist }
   };
 }
 function toOpensteerResolvedTarget2(target) {
@@ -22953,12 +23046,16 @@ function toOpensteerResolvedTarget2(target) {
     documentRef: target.documentRef,
     documentEpoch: target.documentEpoch,
     nodeRef: target.nodeRef,
-    tagName: target.node.nodeName.toUpperCase(),
+    tagName: toOpensteerTagName2(target.node.nodeName),
     pathHint: buildPathSelectorHint(target.replayPath ?? target.anchor),
     ...target.persist === void 0 ? {} : { persist: target.persist },
     ...target.selectorUsed === void 0 ? {} : { selectorUsed: target.selectorUsed }
   };
 }
+function toOpensteerTagName2(nodeName) {
+  const tagName = String(nodeName).trim().toLowerCase();
+  return tagName.length === 0 ? "element" : tagName;
+}
 function normalizeOpensteerError(error) {
   return normalizeThrownOpensteerError(error, "Unknown Opensteer runtime failure");
 }
@@ -23196,7 +23293,10 @@ var init_runtime3 = __esm({
       sessionRef;
       pageRef;
       runId;
-      observations;
+      observationSessions = /* @__PURE__ */ new Map();
+      openingObservationSessions = /* @__PURE__ */ new Map();
+      openedObservationSessions = /* @__PURE__ */ new Set();
+      observationSessionStorage = new async_hooks.AsyncLocalStorage();
       operationEventStorage = new async_hooks.AsyncLocalStorage();
       pendingOperationEventCaptures = [];
       ownsEngine = false;
@@ -23248,18 +23348,26 @@ var init_runtime3 = __esm({
       }
       async setObservabilityConfig(input) {
         this.observationConfig = normalizeObservabilityConfig(input);
-        const observationSessionId = this.resolveObservationSessionId();
-        if (observationSessionId === void 0) {
-          return this.observationConfig;
-        }
-        const sink = this.injectedObservationSink ?? (await this.ensureRoot()).observations;
-        this.observations = await sink.openSession({
-          sessionId: observationSessionId,
-          openedAt: Date.now(),
-          config: this.observationConfig
-        });
+        await this.ensureConfiguredObservationSession();
         return this.observationConfig;
       }
+      async withObservationSessionId(sessionId, task) {
+        return await this.observationSessionStorage.run(
+          {
+            mode: "session",
+            sessionId: normalizeNonEmptyString("sessionId", sessionId)
+          },
+          task
+        );
+      }
+      async withoutObservationSession(task) {
+        return await this.observationSessionStorage.run(
+          {
+            mode: "disabled"
+          },
+          task
+        );
+      }
       async open(input = {}, options = {}) {
         assertValidSemanticOperationInput("session.open", input);
         if (input.workspace !== void 0 && normalizeNamespace2(input.workspace) !== this.workspace) {
@@ -23276,7 +23384,7 @@ var init_runtime3 = __esm({
               options
             );
           }
-          return this.readSessionState();
+          return this.readNavigationSummary();
         }
         const startedAt = Date.now();
         const root = await this.ensureRoot();
@@ -23297,7 +23405,8 @@ var init_runtime3 = __esm({
               openedSessionRef = sessionRef;
               const createdPage = await timeout.runStep(
                 () => engine.createPage({
-                  sessionRef
+                  sessionRef,
+                  ...input.url === void 0 ? {} : { url: input.url }
                 })
               );
               openedPageRef = createdPage.data.pageRef;
@@ -23307,18 +23416,19 @@ var init_runtime3 = __esm({
               await timeout.runStep(() => this.ensureSemantics());
               let frameRef2 = createdPage.frameRef;
               if (input.url !== void 0) {
-                const navigation = await this.navigatePage(
-                  {
+                await timeout.runStep(
+                  () => settleWithPolicy(this.policy.settle, {
                     operation: "session.open",
+                    trigger: "navigation",
+                    engine: this.requireEngine(),
                     pageRef: createdPage.data.pageRef,
-                    url: input.url
-                  },
-                  timeout
+                    signal: timeout.signal,
+                    remainingMs: timeout.remainingMs()
+                  })
                 );
-                frameRef2 = navigation.data.mainFrame.frameRef;
               }
               return {
-                state: await timeout.runStep(() => this.readSessionState()),
+                state: await timeout.runStep(() => this.readNavigationSummary()),
                 frameRef: frameRef2
               };
             },
@@ -23411,7 +23521,11 @@ var init_runtime3 = __esm({
               "page.new cannot use openerPageRef before a session exists"
             );
           }
-          return this.open(input.url === void 0 ? {} : { url: input.url }, options);
+          const summary = await this.open(input.url === void 0 ? {} : { url: input.url }, options);
+          return {
+            pageRef: await this.ensurePageRef(),
+            ...summary
+          };
         }
         const startedAt = Date.now();
         try {
@@ -23426,7 +23540,7 @@ var init_runtime3 = __esm({
                 })
               );
               this.pageRef = created.data.pageRef;
-              return this.readSessionState();
+              return this.readCreatedPageOutput(created.data.pageRef);
             },
             options
           );
@@ -23468,7 +23582,7 @@ var init_runtime3 = __esm({
                 () => this.requireEngine().activatePage({ pageRef: input.pageRef })
               );
               this.pageRef = input.pageRef;
-              return this.readSessionState();
+              return this.readNavigationSummary(input.pageRef);
             },
             options
           );
@@ -23594,7 +23708,7 @@ var init_runtime3 = __esm({
               timeout.throwIfAborted();
               return {
                 navigation: navigation2,
-                state: await timeout.runStep(() => this.readSessionState())
+                state: await timeout.runStep(() => this.readNavigationSummary(pageRef))
               };
             },
             (diagnostics) => {
@@ -24828,7 +24942,7 @@ var init_runtime3 = __esm({
         let mutationCaptureDiagnostics;
         let boundaryDiagnostics;
         try {
-          const { artifacts, output } = await this.runMutationCapturedOperation(
+          const { artifacts, output, result } = await this.runMutationCapturedOperation(
             "computer.execute",
             {
               ...input.captureNetwork === void 0 ? {} : { captureNetwork: input.captureNetwork },
@@ -24846,9 +24960,14 @@ var init_runtime3 = __esm({
                 await this.invalidateLiveSnapshotCounters([pageRef, output2.pageRef], timeout);
                 this.pageRef = output2.pageRef;
                 const artifacts2 = await this.persistComputerArtifacts(output2, timeout);
+                const result2 = {
+                  ...await timeout.runStep(() => this.readNavigationSummary(output2.pageRef)),
+                  screenshot: artifacts2.screenshot
+                };
                 return {
                   artifacts: { manifests: artifacts2.manifests },
-                  output: artifacts2.output
+                  output: output2,
+                  result: result2
                 };
               } catch (error) {
                 boundaryDiagnostics ??= takeActionBoundaryDiagnostics(timeout.signal);
@@ -24885,7 +25004,7 @@ var init_runtime3 = __esm({
               documentEpoch: output.screenshot.documentEpoch
             })
           });
-          return output;
+          return result;
         } catch (error) {
           await this.appendTrace({
             operation: "computer.execute",
@@ -25033,8 +25152,9 @@ var init_runtime3 = __esm({
               mutationCaptureDiagnostics = diagnostics;
             }
           );
-          const output = toOpensteerActionResult(executed.result);
+          const output = toOpensteerActionResult(executed.result.resolved);
           const actionEvents = "events" in executed.result ? executed.result.events : void 0;
+          const resolvedTarget = toOpensteerResolvedTarget2(executed.result.resolved);
           await this.appendTrace({
             operation,
             startedAt,
@@ -25042,8 +25162,13 @@ var init_runtime3 = __esm({
             outcome: "ok",
             ...actionEvents === void 0 ? {} : { events: actionEvents },
             data: {
-              target: output.target,
-              ...output.point === void 0 ? {} : { point: output.point },
+              target: resolvedTarget,
+              ..."point" in executed.result && executed.result.point !== void 0 ? {
+                point: {
+                  x: executed.result.point.x,
+                  y: executed.result.point.y
+                }
+              } : {},
               ...boundaryDiagnostics === void 0 ? {} : { settle: boundaryDiagnostics },
               ...buildMutationCaptureTraceData(mutationCaptureDiagnostics)
             },
@@ -26508,20 +26633,20 @@ var init_runtime3 = __esm({
           throw error;
         }
       }
-      async readSessionState() {
-        const pageRef = await this.ensurePageRef();
+      async readNavigationSummary(targetPageRef) {
+        const pageRef = targetPageRef ?? await this.ensurePageRef();
         const pageInfo = await this.requireEngine().getPageInfo({ pageRef });
-        const sessionRef = this.sessionRef;
-        if (!sessionRef) {
-          throw new Error("Opensteer session is not initialized");
-        }
         return {
-          sessionRef,
-          pageRef,
           url: pageInfo.url,
           title: pageInfo.title
         };
       }
+      async readCreatedPageOutput(pageRef) {
+        return {
+          pageRef,
+          ...await this.readNavigationSummary(pageRef)
+        };
+      }
       async captureSnapshotArtifacts(pageRef, options, timeout) {
         const root = this.requireRoot();
         const mainFrame = await timeout.runStep(() => getMainFrame(this.requireEngine(), pageRef));
@@ -26593,12 +26718,12 @@ var init_runtime3 = __esm({
         const screenshotPayload = manifestToExternalBinaryLocation(root.rootPath, screenshotManifest);
         return {
           manifests,
-          output: {
-            ...output,
-            screenshot: {
-              ...output.screenshot,
-              payload: screenshotPayload
-            }
+          screenshot: {
+            payload: screenshotPayload,
+            format: output.screenshot.format,
+            size: output.screenshot.size,
+            coordinateSpace: output.screenshot.coordinateSpace,
+            ...output.screenshot.clip === void 0 ? {} : { clip: output.screenshot.clip }
           }
         };
       }
@@ -26686,7 +26811,7 @@ var init_runtime3 = __esm({
       }
       async resetRuntimeState(options) {
         const engine = this.engine;
-        const observations = this.observations;
+        const observationSessions = [...this.openedObservationSessions];
         this.networkHistory.clear();
         this.sessionRef = void 0;
         this.pageRef = void 0;
@@ -26695,9 +26820,15 @@ var init_runtime3 = __esm({
         this.computer = void 0;
         this.extractionDescriptors = void 0;
         this.engine = void 0;
-        this.observations = void 0;
+        this.observationSessions.clear();
+        this.openingObservationSessions.clear();
+        this.openedObservationSessions.clear();
         this.pendingOperationEventCaptures.length = 0;
-        await observations?.close("runtime_reset").catch(() => void 0);
+        await Promise.allSettled(
+          observationSessions.map(
+            (observationSession) => observationSession.close("runtime_reset").catch(() => void 0)
+          )
+        );
         if (options.disposeEngine && this.ownsEngine && engine?.dispose) {
           await engine.dispose();
         }
@@ -26707,23 +26838,64 @@ var init_runtime3 = __esm({
         if (this.observationConfig.profile === "off") {
           return void 0;
         }
-        if (this.observations !== void 0) {
-          return this.observations;
+        const observationSessionId = this.resolveObservationSessionId();
+        if (observationSessionId === void 0) {
+          return void 0;
+        }
+        const existingObservationSession = this.observationSessions.get(observationSessionId);
+        if (existingObservationSession !== void 0) {
+          return existingObservationSession;
+        }
+        const openingObservationSession = this.openingObservationSessions.get(observationSessionId);
+        if (openingObservationSession !== void 0) {
+          return await openingObservationSession;
+        }
+        const openObservationSessionTask = this.openObservationSession(observationSessionId).finally(
+          () => {
+            this.openingObservationSessions.delete(observationSessionId);
+          }
+        );
+        this.openingObservationSessions.set(observationSessionId, openObservationSessionTask);
+        return await openObservationSessionTask;
+      }
+      async ensureConfiguredObservationSession() {
+        if (this.observationConfig.profile === "off") {
+          return void 0;
         }
         const observationSessionId = this.resolveObservationSessionId();
         if (observationSessionId === void 0) {
           return void 0;
         }
+        const hadObservationSession = this.observationSessions.has(observationSessionId) || this.openingObservationSessions.has(observationSessionId);
+        const observationSession = await this.ensureObservationSession();
+        if (observationSession !== void 0 && hadObservationSession) {
+          await observationSession.configure?.({
+            config: this.observationConfig,
+            updatedAt: Date.now()
+          });
+        }
+        return observationSession;
+      }
+      resolveObservationSessionId() {
+        const scopedSession = this.observationSessionStorage.getStore();
+        if (scopedSession?.mode === "session") {
+          return scopedSession.sessionId;
+        }
+        if (scopedSession?.mode === "disabled") {
+          return void 0;
+        }
+        return this.observationSessionId ?? this.sessionRef;
+      }
+      async openObservationSession(sessionId) {
         const sink = this.injectedObservationSink ?? (await this.ensureRoot()).observations;
-        this.observations = await sink.openSession({
-          sessionId: observationSessionId,
+        const observationSession = await sink.openSession({
+          sessionId,
           openedAt: Date.now(),
           config: this.observationConfig
         });
-        return this.observations;
-      }
-      resolveObservationSessionId() {
-        return this.observationSessionId ?? this.sessionRef;
+        this.observationSessions.set(sessionId, observationSession);
+        this.openedObservationSessions.add(observationSession);
+        return observationSession;
       }
       runWithOperationTimeout(operation, callback, options = {}) {
         const timeoutPolicy = options.timeoutMs === void 0 ? this.policy.timeout : {
@@ -28683,7 +28855,11 @@ function generateReplayScript(options) {
     ``,
     ...renderOpensteerBootstrap(replayTarget),
     ``,
-    `const ${initialPageId} = (await opensteer.open(${JSON.stringify(initialPages[0]?.initialUrl ?? "")})).pageRef;`,
+    `await opensteer.open(${JSON.stringify(initialPages[0]?.initialUrl ?? "")});`,
+    `const ${initialPageId} = (await opensteer.listPages()).activePageRef;`,
+    `if (!${initialPageId}) {`,
+    `  throw new Error("Opensteer did not report an active page after open().");`,
+    `}`,
     `let activePageRef: string | undefined = ${initialPageId};`,
     ``,
     `async function ensureActive(pageRef: string): Promise<void> {`,
@@ -28887,26 +29063,35 @@ function renderOpensteerBootstrap(replayTarget) {
     `const opensteer = new Opensteer({`,
     `  provider: {`,
     `    mode: "cloud",`,
-    `    baseUrl: requireEnv(${JSON.stringify(replayTarget.baseUrlEnvVar ?? "OPENSTEER_BASE_URL")}),`,
     `    apiKey: requireEnv(${JSON.stringify(replayTarget.apiKeyEnvVar ?? "OPENSTEER_API_KEY")}),`,
+    ...renderCloudBaseUrl(replayTarget),
     ...renderCloudBrowserProfile(replayTarget),
     `  },`,
     `});`
   ];
 }
 function renderRequireEnvHelper(replayTarget) {
-  const baseUrlEnvVar = replayTarget.baseUrlEnvVar ?? "OPENSTEER_BASE_URL";
   const apiKeyEnvVar = replayTarget.apiKeyEnvVar ?? "OPENSTEER_API_KEY";
+  const requiredEnvVars = [
+    ...replayTarget.baseUrlEnvVar === void 0 ? [] : [replayTarget.baseUrlEnvVar],
+    apiKeyEnvVar
+  ];
   return [
     `function requireEnv(name: string): string {`,
     `  const value = process.env[name];`,
     `  if (typeof value === "string" && value.trim().length > 0) {`,
     `    return value;`,
     `  }`,
-    `  throw new Error(\`Missing environment variable \${name}. Set ${baseUrlEnvVar} and ${apiKeyEnvVar} before replaying this recording.\`);`,
+    `  throw new Error(\`Missing environment variable \${name}. Set ${requiredEnvVars.join(" and ")} before replaying this recording.\`);`,
     `}`
   ].join("\n");
 }
+function renderCloudBaseUrl(replayTarget) {
+  if (replayTarget.baseUrlEnvVar === void 0) {
+    return [];
+  }
+  return [`    baseUrl: requireEnv(${JSON.stringify(replayTarget.baseUrlEnvVar)}),`];
+}
 function renderCloudBrowserProfile(replayTarget) {
   if (replayTarget.browserProfileId === void 0) {
     return [];
@@ -30169,6 +30354,41 @@ var init_session_proxy = __esm({
     };
   }
 });
+async function persistLocalActivePageHint(runtime, rootPath) {
+  try {
+    await syncPersistedLocalActivePageHint(runtime, rootPath);
+  } catch {
+  }
+}
+async function syncPersistedLocalActivePageHint(runtime, rootPath) {
+  const record = await readPersistedLocalBrowserSessionRecord(rootPath);
+  if (!record) {
+    return;
+  }
+  const sessionInfo = await runtime.info();
+  const activePageRef = sessionInfo.activePageRef;
+  let activePageUrl;
+  let activePageTitle;
+  if (activePageRef !== void 0) {
+    const pages = await runtime.listPages();
+    const activePage = pages.pages.find((page) => page.pageRef === activePageRef);
+    activePageUrl = activePage?.url;
+    activePageTitle = activePage?.title;
+  }
+  const {
+    activePageRef: _previousActivePageRef,
+    activePageUrl: _previousActivePageUrl,
+    activePageTitle: _previousActivePageTitle,
+    ...restRecord
+  } = record;
+  await writePersistedSessionRecord(rootPath, {
+    ...restRecord,
+    updatedAt: Date.now(),
+    ...activePageRef === void 0 ? {} : { activePageRef },
+    ...activePageUrl === void 0 ? {} : { activePageUrl },
+    ...activePageTitle === void 0 ? {} : { activePageTitle }
+  });
+}
 function buildSharedRuntimeOptions(input) {
   const ownership = resolveOwnership(input.browser);
   const engineFactory = input.engineFactory ?? ((factoryOptions) => new OpensteerBrowserManager({
@@ -30215,14 +30435,37 @@ function normalizeWorkspace2(workspace) {
 function resolveOwnership(browser) {
   return typeof browser === "object" && browser.mode === "attach" ? "attached" : "owned";
 }
-var OpensteerRuntime;
+var LocalActivePageHintRuntime, OpensteerRuntime;
 var init_runtime4 = __esm({
   "src/sdk/runtime.ts"() {
     init_src3();
     init_browser_manager();
     init_engine_selection2();
+    init_live_session();
     init_root2();
-    OpensteerRuntime = class extends OpensteerSessionRuntime {
+    LocalActivePageHintRuntime = class extends OpensteerSessionRuntime {
+      async completeWithLocalActivePageHint(operation) {
+        const output = await operation();
+        await persistLocalActivePageHint(this, this.rootPath);
+        return output;
+      }
+      async open(input = {}, options = {}) {
+        return this.completeWithLocalActivePageHint(() => super.open(input, options));
+      }
+      async newPage(input = {}, options = {}) {
+        return this.completeWithLocalActivePageHint(() => super.newPage(input, options));
+      }
+      async activatePage(input, options = {}) {
+        return this.completeWithLocalActivePageHint(() => super.activatePage(input, options));
+      }
+      async closePage(input = {}, options = {}) {
+        return this.completeWithLocalActivePageHint(() => super.closePage(input, options));
+      }
+      async goto(input, options = {}) {
+        return this.completeWithLocalActivePageHint(() => super.goto(input, options));
+      }
+    };
+    OpensteerRuntime = class extends LocalActivePageHintRuntime {
       constructor(options = {}) {
         const publicWorkspace = normalizeWorkspace2(options.workspace);
         const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path10__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
@@ -30944,7 +31187,7 @@ var init_opensteer = __esm({
 
 // package.json
 var package_default = {
-  version: "0.9.6"};
+  version: "0.9.8"};
 
 // src/cli/bin.ts
 init_browser_manager();
@@ -31599,14 +31842,22 @@ async function buildOperationInput(operation, parsed, runtime) {
       return parsed.rest[0] === void 0 ? {} : { mode: parsed.rest[0] };
     case "page.evaluate":
       if (parsed.rest[0] === void 0) {
-        throw new CliError("missing_arguments", "evaluate requires a script.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "evaluate requires a script.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       return {
         script: joinRest(parsed.rest, 0)
       };
     case "page.add-init-script":
       if (parsed.rest[0] === void 0) {
-        throw new CliError("missing_arguments", "init-script requires a script.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "init-script requires a script.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       return {
         script: joinRest(parsed.rest, 0)
@@ -31622,7 +31873,11 @@ async function buildOperationInput(operation, parsed, runtime) {
       return buildElementTargetInput(parsed, "hover");
     case "dom.input": {
       if (parsed.rest[1] === void 0) {
-        throw new CliError("missing_arguments", "input requires an element number and text.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "input requires an element number and text.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       const pressEnter = readOptionalBoolean(parsed.rawOptions, "press-enter");
       return {
@@ -31653,7 +31908,11 @@ async function buildOperationInput(operation, parsed, runtime) {
     }
     case "dom.extract": {
       if (parsed.rest[0] === void 0) {
-        throw new CliError("missing_arguments", "extract requires a template.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "extract requires a template.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       const persist = readPersistKey(parsed, "extract");
       return {
@@ -31689,7 +31948,11 @@ async function buildOperationInput(operation, parsed, runtime) {
     }
     case "network.detail": {
       if (parsed.rest[0] === void 0) {
-        throw new CliError("missing_arguments", "network detail requires a record id.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "network detail requires a record id.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       const probeFlag = readOptionalBoolean(parsed.rawOptions, "probe");
       return {
@@ -31700,7 +31963,11 @@ async function buildOperationInput(operation, parsed, runtime) {
     case "session.fetch": {
       const url = parsed.rest[0];
       if (url === void 0) {
-        throw new CliError("missing_arguments", "fetch requires a URL.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "fetch requires a URL.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       const bodyJson = readJsonValue(parsed.rawOptions, "body");
       const bodyText = readSingle(parsed.rawOptions, "body-text");
@@ -31739,7 +32006,11 @@ async function buildOperationInput(operation, parsed, runtime) {
       const siteKey = readSingle(parsed.rawOptions, "site-key");
       const pageUrl = readSingle(parsed.rawOptions, "page-url");
       if (provider === void 0 || apiKey === void 0) {
-        throw new CliError("missing_arguments", 'captcha solve requires "--provider" and "--api-key".', CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          'captcha solve requires "--provider" and "--api-key".',
+          CLI_USAGE_HINTS[operation]
+        );
       }
       return {
         provider: readCaptchaProvider(provider),
@@ -31769,7 +32040,11 @@ async function buildOperationInput(operation, parsed, runtime) {
     case "scripts.beautify":
     case "scripts.deobfuscate": {
       if (parsed.rest[0] === void 0) {
-        throw new CliError("missing_arguments", `${parsed.command.join(" ")} requires an artifact id.`, CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          `${parsed.command.join(" ")} requires an artifact id.`,
+          CLI_USAGE_HINTS[operation]
+        );
       }
       const persist = readOptionalBoolean(parsed.rawOptions, "persist");
       return {
@@ -31779,7 +32054,11 @@ async function buildOperationInput(operation, parsed, runtime) {
     }
     case "scripts.sandbox":
       if (parsed.rest[0] === void 0) {
-        throw new CliError("missing_arguments", "scripts sandbox requires an artifact id.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "scripts sandbox requires an artifact id.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       {
         const fidelity = readSingle(parsed.rawOptions, "fidelity");
@@ -31828,14 +32107,22 @@ async function buildOperationInput(operation, parsed, runtime) {
     case "interaction.get":
     case "interaction.replay":
       if (parsed.rest[0] === void 0) {
-        throw new CliError("missing_arguments", `${parsed.command.join(" ")} requires a trace id.`, CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          `${parsed.command.join(" ")} requires a trace id.`,
+          CLI_USAGE_HINTS[operation]
+        );
       }
       return {
         traceId: parsed.rest[0]
       };
     case "interaction.diff":
       if (parsed.rest[0] === void 0 || parsed.rest[1] === void 0) {
-        throw new CliError("missing_arguments", "interaction diff requires two trace ids.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "interaction diff requires two trace ids.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       return {
         leftTraceId: parsed.rest[0],
@@ -31843,7 +32130,11 @@ async function buildOperationInput(operation, parsed, runtime) {
       };
     case "artifact.read":
       if (parsed.rest[0] === void 0) {
-        throw new CliError("missing_arguments", "artifact read requires an artifact id.", CLI_USAGE_HINTS[operation]);
+        throw new CliError(
+          "missing_arguments",
+          "artifact read requires an artifact id.",
+          CLI_USAGE_HINTS[operation]
+        );
       }
       return {
         artifactId: parsed.rest[0]
@@ -31981,7 +32272,10 @@ function buildComputerExecuteInput(parsed) {
         }
       };
     default:
-      throw new CliError("unknown_command", `Unknown computer command: ${parsed.command.join(" ")}`);
+      throw new CliError(
+        "unknown_command",
+        `Unknown computer command: ${parsed.command.join(" ")}`
+      );
   }
 }
 async function resolvePageRefByIndex(runtime, index) {
@@ -32011,7 +32305,10 @@ function readRequiredNumber(value, message) {
 }
 function readSingleDirection(value) {
   if (value === void 0 || !SCROLL_DIRECTIONS.has(value)) {
-    throw new CliError("missing_arguments", "scroll requires a direction: up, down, left, or right.");
+    throw new CliError(
+      "missing_arguments",
+      "scroll requires a direction: up, down, left, or right."
+    );
   }
   return value;
 }
@@ -32038,13 +32335,19 @@ function readCaptchaProvider(value) {
 }
 function readCaptchaType(value) {
   if (value === void 0 || !CAPTCHA_TYPES.has(value)) {
-    throw new CliError("invalid_value", 'Expected "--type" to be one of: recaptcha-v2, hcaptcha, turnstile.');
+    throw new CliError(
+      "invalid_value",
+      'Expected "--type" to be one of: recaptcha-v2, hcaptcha, turnstile.'
+    );
   }
   return value;
 }
 function readSandboxFidelity(value) {
   if (value === void 0 || !SANDBOX_FIDELITIES.has(value)) {
-    throw new CliError("invalid_value", 'Expected "--fidelity" to be one of: minimal, standard, full.');
+    throw new CliError(
+      "invalid_value",
+      'Expected "--fidelity" to be one of: minimal, standard, full.'
+    );
   }
   return value;
 }
@@ -32067,7 +32370,10 @@ function readKeyModifiers(value) {
   }
   for (const modifier of modifiers) {
     if (!KEY_MODIFIERS.has(modifier)) {
-      throw new CliError("invalid_value", 'Expected "--modifiers" to contain only: Shift, Control, Alt, Meta.');
+      throw new CliError(
+        "invalid_value",
+        'Expected "--modifiers" to contain only: Shift, Control, Alt, Meta.'
+      );
     }
   }
   return [...new Set(modifiers)];
@@ -32102,6 +32408,7 @@ function joinRest(rest, startIndex) {
 function renderOperationOutput(operation, result, input) {
   switch (operation) {
     case "session.open":
+    case "page.activate":
     case "page.goto":
       return renderJson(formatNavigationOutput(result));
     case "page.snapshot":
@@ -32110,14 +32417,14 @@ function renderOperationOutput(operation, result, input) {
     case "dom.hover":
     case "dom.input":
     case "dom.scroll":
-      return renderJson(formatActionOutput(result, input));
+      return renderJson(formatActionOutput(result));
     case "dom.extract":
       return renderJson(formatExtractOutput(result));
     case "page.list":
-    case "page.new":
-    case "page.activate":
     case "page.close":
       return formatTabOutput(result);
+    case "page.new":
+      return renderJson(formatCreatedPageOutput(result));
     case "network.query":
       return formatNetworkQueryOutput(result, input);
     case "network.detail":
@@ -32155,6 +32462,12 @@ function formatNavigationOutput(result) {
     ...readStringField(result, "title") === void 0 ? {} : { title: readStringField(result, "title") }
   };
 }
+function formatCreatedPageOutput(result) {
+  return {
+    ...readStringField(result, "pageRef") === void 0 ? {} : { pageRef: readStringField(result, "pageRef") },
+    ...formatNavigationOutput(result)
+  };
+}
 function formatSnapshotOutput(result) {
   if (result !== null && typeof result === "object" && typeof result.html === "string") {
     return `${result.html}
@@ -32162,36 +32475,11 @@ function formatSnapshotOutput(result) {
   }
   return renderJson(result);
 }
-function formatActionOutput(result, input) {
-  const target = readObjectField(result, "target");
-  const output = {
-    ...readStringField(target, "tagName") === void 0 ? {} : { tagName: readStringField(target, "tagName") },
-    ...readStringField(target, "pathHint") === void 0 ? {} : { pathHint: readStringField(target, "pathHint") }
+function formatActionOutput(result) {
+  return {
+    ...readStringField(result, "tagName") === void 0 ? {} : { tagName: readStringField(result, "tagName") },
+    ...readStringField(result, "persist") === void 0 ? {} : { persist: readStringField(result, "persist") }
   };
-  const point = readObjectField(result, "point");
-  if (point !== void 0) {
-    output.point = {
-      ...readNumberField(point, "x") === void 0 ? {} : { x: readNumberField(point, "x") },
-      ...readNumberField(point, "y") === void 0 ? {} : { y: readNumberField(point, "y") }
-    };
-  }
-  const persist = readStringField(target, "persist");
-  if (persist !== void 0) {
-    output.persist = persist;
-  }
-  const text = readStringField(input, "text");
-  if (text !== void 0) {
-    output.text = text;
-  }
-  const direction = readStringField(input, "direction");
-  if (direction !== void 0) {
-    output.direction = direction;
-  }
-  const amount = readNumberField(input, "amount");
-  if (amount !== void 0) {
-    output.amount = amount;
-  }
-  return output;
 }
 function formatExtractOutput(result) {
   const data = readUnknownField(result, "data");
@@ -32423,20 +32711,18 @@ function formatStateOutput(result) {
 `;
 }
 function formatComputerOutput(result) {
-  const action = readObjectField(result, "action");
   const screenshot = readObjectField(result, "screenshot");
   const payload = readObjectField(screenshot, "payload");
-  const timing = readObjectField(result, "timing");
   return {
-    ...action === void 0 ? {} : { action },
+    ...readStringField(result, "url") === void 0 ? {} : { url: readStringField(result, "url") },
+    ...readStringField(result, "title") === void 0 ? {} : { title: readStringField(result, "title") },
     ...payload === void 0 ? {} : {
       screenshot: {
         ...readStringField(payload, "uri") === void 0 ? {} : { uri: readStringField(payload, "uri") },
         ...readStringField(screenshot, "format") === void 0 ? {} : { format: readStringField(screenshot, "format") },
         ...readObjectField(screenshot, "size") === void 0 ? {} : { size: readObjectField(screenshot, "size") }
       }
-    },
-    ...timing === void 0 ? {} : { timingMs: timing }
+    }
   };
 }
 function formatScriptsCaptureOutput(result) {
@@ -33098,7 +33384,7 @@ async function collectOpensteerStatus(input) {
     ...output,
     rootPath,
     lanes: {
-      local: describeLocalLane(localRecord, input.provider.mode === "local"),
+      local: await describeLocalLane(localRecord, input.provider.mode === "local"),
       cloud: await describeCloudLane({
         record: cloudRecord,
         current: input.provider.mode === "cloud",
@@ -33150,8 +33436,38 @@ async function readWorkspaceCloudRecord(rootPath) {
   }
   return readPersistedCloudSessionRecord(rootPath);
 }
-function describeLocalLane(record, current) {
-  if (record === void 0 || !isProcessRunning(record.pid)) {
+async function describeLocalLane(record, current) {
+  if (record === void 0) {
+    return {
+      provider: "local",
+      status: "idle",
+      current,
+      summary: "none"
+    };
+  }
+  if (getPersistedLocalBrowserSessionOwnership(record) === "attached") {
+    if (!await isAttachedLocalBrowserSessionReachable(record)) {
+      return {
+        provider: "local",
+        status: "stale",
+        current,
+        summary: "attached browser unavailable",
+        detail: record.engine,
+        engine: record.engine
+      };
+    }
+    const browser2 = record.executablePath ? path10__default.default.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
+    return {
+      provider: "local",
+      status: "active",
+      current,
+      summary: "attached browser",
+      detail: browser2 ?? record.engine,
+      engine: record.engine,
+      ...browser2 === void 0 ? {} : { browser: browser2 }
+    };
+  }
+  if (!isProcessRunning(record.pid)) {
     return {
       provider: "local",
       status: "idle",
@@ -33302,13 +33618,13 @@ async function resolveSessionSummary(manifest) {
   return {
     sessionId: manifest.sessionId,
     label: manifest.workspace ?? (path10__default.default.basename(manifest.rootPath) || manifest.sessionId),
-    status: isProcessRunning(record.pid) ? "live" : "stale",
+    status: getPersistedLocalBrowserSessionOwnership(record) === "attached" || isProcessRunning(record.pid) ? "live" : "stale",
     ...manifest.workspace === void 0 ? {} : { workspace: manifest.workspace },
     rootPath: manifest.rootPath,
     engine: record.engine,
     ownership: manifest.ownership,
-    pid: record.pid,
     startedAt: record.startedAt,
+    ...record.pid > 0 ? { pid: record.pid } : {},
     ...browserName === void 0 ? {} : { browserName }
   };
 }
@@ -33336,7 +33652,16 @@ async function readLiveRecord(manifest) {
   if (!record) {
     return void 0;
   }
-  if (record.pid !== manifest.pid || record.startedAt !== manifest.startedAt || !isProcessRunning(record.pid)) {
+  if (buildLocalViewSessionIdForRecord({
+    rootPath: manifest.rootPath,
+    live: record
+  }) !== manifest.sessionId || record.startedAt !== manifest.startedAt || record.engine !== manifest.engine || getPersistedLocalBrowserSessionOwnership(record) !== manifest.ownership) {
+    return void 0;
+  }
+  if (getPersistedLocalBrowserSessionOwnership(record) === "attached") {
+    return await isAttachedLocalBrowserSessionReachable(record) ? record : void 0;
+  }
+  if (record.pid !== manifest.pid || !isProcessRunning(record.pid)) {
     return void 0;
   }
   return record;
@@ -33630,6 +33955,172 @@ init_process_owner();
 init_service_state();
 init_service_state();
 
+// src/local-view/browser-target-order.ts
+async function readPageTargetId(page) {
+  const cdp = await page.context().newCDPSession(page);
+  try {
+    const result = await cdp.send("Target.getTargetInfo");
+    const targetId = result?.targetInfo?.targetId;
+    return typeof targetId === "string" && targetId.length > 0 ? targetId : null;
+  } finally {
+    await cdp.detach().catch(() => void 0);
+  }
+}
+async function readBrowserPageTargetOrder(browserContext) {
+  const browser = browserContext.browser();
+  if (!browser || !hasBrowserCdpSession(browser)) {
+    return [];
+  }
+  const cdp = await browser.newBrowserCDPSession();
+  try {
+    const result = await cdp.send("Target.getTargets");
+    return normalizeBrowserPageTargetOrder(result?.targetInfos ?? []);
+  } catch {
+    return [];
+  } finally {
+    await cdp.detach().catch(() => void 0);
+  }
+}
+async function orderPagesByBrowserTargetOrder(browserContext, pages) {
+  if (pages.length < 2) {
+    return pages;
+  }
+  const orderedTargetIds = await readBrowserPageTargetOrder(browserContext);
+  if (orderedTargetIds.length === 0) {
+    return pages;
+  }
+  const rankByTargetId = new Map(orderedTargetIds.map((targetId, index) => [targetId, index]));
+  const targetIds = await Promise.all(
+    pages.map((page) => readPageTargetId(page).catch(() => null))
+  );
+  return pages.map((page, index) => {
+    const targetId = targetIds[index] ?? void 0;
+    return {
+      page,
+      index,
+      rank: targetId === void 0 ? void 0 : rankByTargetId.get(targetId)
+    };
+  }).sort((left, right) => {
+    if (left.rank !== void 0 && right.rank !== void 0) {
+      return left.rank - right.rank;
+    }
+    if (left.rank !== void 0) {
+      return -1;
+    }
+    if (right.rank !== void 0) {
+      return 1;
+    }
+    return left.index - right.index;
+  }).map((entry) => entry.page);
+}
+function hasBrowserCdpSession(browser) {
+  return typeof browser.newBrowserCDPSession === "function";
+}
+function normalizeBrowserPageTargetOrder(targetInfos) {
+  const reversedPageInfos = [];
+  for (const targetInfo of targetInfos) {
+    if (targetInfo.type !== "page") {
+      continue;
+    }
+    const targetId = typeof targetInfo.targetId === "string" && targetInfo.targetId.length > 0 ? targetInfo.targetId : void 0;
+    if (targetId === void 0) {
+      continue;
+    }
+    reversedPageInfos.push({
+      targetId,
+      openerId: typeof targetInfo.openerId === "string" && targetInfo.openerId.length > 0 ? targetInfo.openerId : void 0
+    });
+  }
+  reversedPageInfos.reverse();
+  const rawTargetInfoById = new Map(
+    reversedPageInfos.map((targetInfo) => [targetInfo.targetId, targetInfo])
+  );
+  const targetInfoById = new Map(
+    reversedPageInfos.map(
+      (targetInfo) => [
+        targetInfo.targetId,
+        {
+          ...targetInfo,
+          openerId: resolveAcyclicOpenerId(targetInfo.targetId, rawTargetInfoById)
+        }
+      ]
+    )
+  );
+  const orderedTargetIds = [];
+  const placed = /* @__PURE__ */ new Set();
+  const placeTarget = (targetId) => {
+    if (placed.has(targetId)) {
+      return;
+    }
+    const targetInfo = targetInfoById.get(targetId);
+    if (!targetInfo) {
+      return;
+    }
+    const openerId = targetInfo.openerId;
+    if (openerId === void 0) {
+      orderedTargetIds.push(targetId);
+      placed.add(targetId);
+      return;
+    }
+    placeTarget(openerId);
+    const openerIndex = orderedTargetIds.indexOf(openerId);
+    const insertionIndex = openerIndex === -1 ? orderedTargetIds.length : findPopupInsertionIndex(orderedTargetIds, openerIndex, openerId, targetInfoById);
+    orderedTargetIds.splice(insertionIndex, 0, targetId);
+    placed.add(targetId);
+  };
+  for (const targetInfo of reversedPageInfos) {
+    placeTarget(targetInfo.targetId);
+  }
+  return orderedTargetIds;
+}
+function resolveAcyclicOpenerId(targetId, targetInfoById) {
+  const openerId = targetInfoById.get(targetId)?.openerId;
+  if (openerId === void 0 || !targetInfoById.has(openerId)) {
+    return void 0;
+  }
+  const visitedTargetIds = /* @__PURE__ */ new Set([targetId]);
+  let currentTargetId = openerId;
+  while (currentTargetId !== void 0) {
+    if (visitedTargetIds.has(currentTargetId)) {
+      return void 0;
+    }
+    visitedTargetIds.add(currentTargetId);
+    currentTargetId = targetInfoById.get(currentTargetId)?.openerId;
+  }
+  return openerId;
+}
+function findPopupInsertionIndex(orderedTargetIds, openerIndex, openerTargetId, targetInfoById) {
+  let index = openerIndex + 1;
+  while (index < orderedTargetIds.length) {
+    const candidateTargetId = orderedTargetIds[index];
+    if (!candidateTargetId || !isDescendantTarget(candidateTargetId, openerTargetId, targetInfoById)) {
+      break;
+    }
+    index += 1;
+  }
+  return index;
+}
+function isDescendantTarget(targetId, ancestorTargetId, targetInfoById) {
+  const visitedTargetIds = /* @__PURE__ */ new Set();
+  let currentTargetId = targetId;
+  while (currentTargetId !== void 0) {
+    if (visitedTargetIds.has(currentTargetId)) {
+      return false;
+    }
+    visitedTargetIds.add(currentTargetId);
+    const currentTargetInfo = targetInfoById.get(currentTargetId);
+    const openerId = currentTargetInfo?.openerId;
+    if (openerId === void 0) {
+      return false;
+    }
+    if (openerId === ancestorTargetId) {
+      return true;
+    }
+    currentTargetId = openerId;
+  }
+  return false;
+}
+
 // src/local-view/tab-state-tracker.ts
 var ACTIVATION_INTENT_DISCOVERY_GRACE_MS = 2e3;
 var TabStateTracker = class {
@@ -33645,6 +34136,7 @@ var TabStateTracker = class {
   boundContextCleanup = null;
   constructor(deps) {
     this.deps = deps;
+    this.lastActivePage = deps.initialActivePage ?? null;
   }
   start() {
     if (this.running) {
@@ -33769,7 +34261,7 @@ var TabStateTracker = class {
       this.updatePolling(pages.length);
       const preferredActivePage = this.lastActivePage ?? pages[0] ?? null;
       const pageStates = await Promise.all(
-        pages.map(async (page, index) => {
+        pages.map(async (page, originalIndex) => {
           const metadata = await this.readPageMetadata(page, {
             refresh: args.refreshMetadata
           });
@@ -33779,7 +34271,7 @@ var TabStateTracker = class {
           };
           return {
             page,
-            index,
+            originalIndex,
             targetId: metadata.targetId,
             url: page.url(),
             title: metadata.title,
@@ -33788,17 +34280,18 @@ var TabStateTracker = class {
           };
         })
       );
+      const orderedPageStates = await this.orderPageStates(pageStates);
       const activePage = this.pickActivePage(
-        pageStates,
+        orderedPageStates,
         this.lastActivePage,
         preferredActivePage,
-        this.resolveIntentPage(pageStates)
+        this.resolveIntentPage(orderedPageStates)
       );
       if (activePage && activePage !== this.lastActivePage) {
         this.lastActivePage = activePage;
         this.deps.onActivePageChanged(activePage);
       }
-      const tabs = pageStates.map((state) => ({
+      const tabs = orderedPageStates.map((state) => ({
         index: state.index,
         ...state.targetId === void 0 ? {} : { targetId: state.targetId },
         url: state.url,
@@ -33848,18 +34341,11 @@ var TabStateTracker = class {
     if (cached) {
       return cached;
     }
-    const cdp = await page.context().newCDPSession(page);
-    try {
-      const result = await cdp.send("Target.getTargetInfo");
-      const targetId = result?.targetInfo?.targetId;
-      if (typeof targetId === "string" && targetId.length > 0) {
-        this.targetIdByPage.set(page, targetId);
-        return targetId;
-      }
-      return null;
-    } finally {
-      await cdp.detach().catch(() => void 0);
+    const targetId = await readPageTargetId(page);
+    if (targetId) {
+      this.targetIdByPage.set(page, targetId);
     }
+    return targetId;
   }
   async readFocusState(page) {
     try {
@@ -33927,6 +34413,33 @@ var TabStateTracker = class {
     this.deps.runtimeState.clearPageActivationIntent(this.deps.sessionId, intent.targetId);
     return { page: matched.page };
   }
+  async orderPageStates(pageStates) {
+    if (pageStates.length < 2) {
+      return pageStates.map(({ originalIndex: _originalIndex, ...state }, index) => ({
+        ...state,
+        index
+      }));
+    }
+    const orderedTargetIds = await readBrowserPageTargetOrder(this.deps.browserContext);
+    const rankByTargetId = new Map(orderedTargetIds.map((targetId, index) => [targetId, index]));
+    return [...pageStates].sort((left, right) => {
+      const leftRank = left.targetId === void 0 ? void 0 : rankByTargetId.get(left.targetId);
+      const rightRank = right.targetId === void 0 ? void 0 : rankByTargetId.get(right.targetId);
+      if (leftRank !== void 0 && rightRank !== void 0) {
+        return leftRank - rightRank;
+      }
+      if (leftRank !== void 0) {
+        return -1;
+      }
+      if (rightRank !== void 0) {
+        return 1;
+      }
+      return left.originalIndex - right.originalIndex;
+    }).map(({ originalIndex: _originalIndex, ...state }, index) => ({
+      ...state,
+      index
+    }));
+  }
 };
 
 // src/local-view/view-stream-capture-policy.ts
@@ -34290,6 +34803,7 @@ var SessionViewStreamProducer = class {
       sessionId: this.deps.sessionId,
       pollMs: TAB_STATE_POLL_MS,
       runtimeState: this.deps.runtimeState,
+      initialActivePage: session.page,
       onActivePageChanged: (page) => {
         this.activePage = page;
         void this.queueBindToPage(page).catch(() => void 0);
@@ -34388,7 +34902,20 @@ var SessionViewStreamProducer = class {
       if (!context) {
         throw new Error("Connected browser did not expose a Chromium browser context.");
       }
-      const page = context.pages()[0] ?? await context.newPage();
+      const existingPages = context.pages();
+      if (existingPages.length === 0) {
+        const page2 = await context.newPage();
+        return {
+          browser,
+          context,
+          page: page2
+        };
+      }
+      const orderedPages = await orderPagesByBrowserTargetOrder(context, existingPages);
+      const page = await resolvePersistedActivePage(orderedPages, {
+        ...resolved.record.activePageUrl === void 0 ? {} : { activePageUrl: resolved.record.activePageUrl },
+        ...resolved.record.activePageTitle === void 0 ? {} : { activePageTitle: resolved.record.activePageTitle }
+      }) ?? orderedPages[0];
       return {
         browser,
         context,
@@ -34733,6 +35260,28 @@ async function disconnectPlaywrightChromiumBrowser2(browser) {
   const { disconnectPlaywrightChromiumBrowser: disconnect } = await import('@opensteer/engine-playwright');
   await disconnect(browser);
 }
+async function resolvePersistedActivePage(pages, input) {
+  if (pages.length === 0) {
+    return null;
+  }
+  if (input.activePageUrl === void 0 && input.activePageTitle === void 0) {
+    return null;
+  }
+  const matchesByUrl = input.activePageUrl === void 0 ? pages : pages.filter((page) => page.url() === input.activePageUrl);
+  if (matchesByUrl.length === 0) {
+    return null;
+  }
+  if (input.activePageTitle === void 0) {
+    return matchesByUrl[0] ?? null;
+  }
+  for (const page of matchesByUrl) {
+    const title = await page.title().catch(() => "");
+    if (title === input.activePageTitle) {
+      return page;
+    }
+  }
+  return matchesByUrl[0] ?? null;
+}
 
 // src/local-view/server.ts
 var DEFAULT_MAX_FPS = 12;
@@ -35105,13 +35654,19 @@ async function resolveWorkspaceSessionId(input) {
     workspace: input.workspace
   });
   const live = await readPersistedLocalBrowserSessionRecord(rootPath);
-  if (!live || !isProcessRunning(live.pid)) {
+  if (!live) {
     return void 0;
   }
-  return buildLocalViewSessionId({
+  if (getPersistedLocalBrowserSessionOwnership(live) === "attached") {
+    if (!await isAttachedLocalBrowserSessionReachable(live)) {
+      return void 0;
+    }
+  } else if (!isProcessRunning(live.pid)) {
+    return void 0;
+  }
+  return buildLocalViewSessionIdForRecord({
     rootPath,
-    pid: live.pid,
-    startedAt: live.startedAt
+    live
   });
 }
 function assertNoViewPreferenceFlag(parsed) {
@@ -35207,7 +35762,10 @@ async function main() {
     throw new CliError("unknown_command", `Unknown command: ${parsed.command.join(" ")}`);
   }
   if (parsed.options.workspace === void 0) {
-    throw new CliError("missing_workspace", 'Stateful commands require "--workspace <id>" or OPENSTEER_WORKSPACE.');
+    throw new CliError(
+      "missing_workspace",
+      'Stateful commands require "--workspace <id>" or OPENSTEER_WORKSPACE.'
+    );
   }
   const { engineName, provider, runtimeProvider } = resolveCliRuntimeSelection(parsed);
   if (operation === "session.close") {
@@ -35254,7 +35812,10 @@ async function main() {
 }
 async function handleExecCommand(parsed) {
   if (parsed.options.workspace === void 0) {
-    throw new CliError("missing_workspace", 'exec requires "--workspace <id>" or OPENSTEER_WORKSPACE.');
+    throw new CliError(
+      "missing_workspace",
+      'exec requires "--workspace <id>" or OPENSTEER_WORKSPACE.'
+    );
   }
   const expression = parsed.rest.join(" ");
   if (!expression) {
@@ -35397,7 +35958,10 @@ async function handleCloseCommand(parsed, engineName, providerMode, runtimeProvi
 }
 async function handleRecordCommandEntry(parsed) {
   if (parsed.options.workspace === void 0) {
-    throw new CliError("missing_workspace", 'record requires "--workspace <id>" or OPENSTEER_WORKSPACE.');
+    throw new CliError(
+      "missing_workspace",
+      'record requires "--workspace <id>" or OPENSTEER_WORKSPACE.'
+    );
   }
   const url = parsed.options.url ?? parsed.rest[0];
   if (url === void 0) {
@@ -35437,7 +36001,10 @@ async function handleRecordCommandEntry(parsed) {
     return;
   }
   if (parsed.options.launch?.headless === true) {
-    throw new CliError("config_conflict", 'record requires a headed browser. Remove "--headless true".');
+    throw new CliError(
+      "config_conflict",
+      'record requires a headed browser. Remove "--headless true".'
+    );
   }
   if (typeof recordBrowser === "object") {
     throw new CliError("config_conflict", 'record does not support browser.mode="attach".');
@@ -35509,7 +36076,10 @@ function resolveCliBootstrapAction(argv) {
 }
 function buildCliBrowserProfile(parsed) {
   if (parsed.options.cloudProfileReuseIfActive === true && parsed.options.cloudProfileId === void 0) {
-    throw new CliError("invalid_option", '"--cloud-profile-reuse-if-active" requires "--cloud-profile-id <id>".');
+    throw new CliError(
+      "invalid_option",
+      '"--cloud-profile-reuse-if-active" requires "--cloud-profile-id <id>".'
+    );
   }
   return parsed.options.cloudProfileId === void 0 ? void 0 : {
     profileId: parsed.options.cloudProfileId,