opensteer 0.8.18 → 0.9.1

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var path7 = require('path');
+var path10 = require('path');
 var crypto = require('crypto');
 var promises = require('fs/promises');
 var url = require('url');
@@ -10,6 +10,7 @@ var os = require('os');
 var enginePlaywright = require('@opensteer/engine-playwright');
 var util = require('util');
 var fs = require('fs');
+var module$1 = require('module');
 var zlib = require('zlib');
 var async_hooks = require('async_hooks');
 var sharp = require('sharp');
@@ -18,6 +19,7 @@ var prettier = require('prettier');
 var vm = require('vm');
 var WebSocket2 = require('ws');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
@@ -38,7 +40,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path7__default = /*#__PURE__*/_interopDefault(path7);
+var path10__default = /*#__PURE__*/_interopDefault(path10);
 var sharp__default = /*#__PURE__*/_interopDefault(sharp);
 var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
 var prettier__namespace = /*#__PURE__*/_interopNamespace(prettier);
@@ -60,30 +62,30 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function canonicalizeJsonValue(value, path15) {
+function canonicalizeJsonValue(value, path18) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new TypeError(`${path15} must be a finite JSON number`);
+      throw new TypeError(`${path18} must be a finite JSON number`);
     }
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path15}[${index}]`));
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path18}[${index}]`));
   }
   if (!isPlainObject(value)) {
-    throw new TypeError(`${path15} must be a plain JSON object`);
+    throw new TypeError(`${path18} must be a plain JSON object`);
   }
   const sorted = Object.keys(value).sort((left, right) => left.localeCompare(right));
   const result = {};
   for (const key of sorted) {
     const entry = value[key];
     if (entry === void 0) {
-      throw new TypeError(`${path15}.${key} must not be undefined`);
+      throw new TypeError(`${path18}.${key} must not be undefined`);
     }
-    result[key] = canonicalizeJsonValue(entry, `${path15}.${key}`);
+    result[key] = canonicalizeJsonValue(entry, `${path18}.${key}`);
   }
   return result;
 }
@@ -120,7 +122,7 @@ function joinStoragePath(...segments) {
   return segments.join("/");
 }
 function resolveStoragePath(rootPath, relativePath) {
-  if (path7__default.default.isAbsolute(relativePath)) {
+  if (path10__default.default.isAbsolute(relativePath)) {
     throw new TypeError(`storage path ${relativePath} must be relative`);
   }
   const segments = relativePath.split("/");
@@ -132,7 +134,7 @@ function resolveStoragePath(rootPath, relativePath) {
       throw new TypeError(`storage path ${relativePath} must not contain path traversal`);
     }
   }
-  return path7__default.default.join(rootPath, ...segments);
+  return path10__default.default.join(rootPath, ...segments);
 }
 async function ensureDirectory(directoryPath) {
   await promises.mkdir(directoryPath, { recursive: true });
@@ -152,7 +154,7 @@ async function writeJsonFileAtomic(filePath, value) {
   await writeTextFileAtomic(filePath, stableJsonString(value));
 }
 async function writeTextFileAtomic(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   const temporaryPath = `${filePath}.${crypto.randomUUID()}.tmp`;
   await promises.writeFile(temporaryPath, value, "utf8");
   await promises.rename(temporaryPath, filePath);
@@ -161,7 +163,7 @@ async function writeJsonFileExclusive(filePath, value) {
   await writeTextFileExclusive(filePath, stableJsonString(value));
 }
 async function writeTextFileExclusive(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   const handle = await promises.open(filePath, "wx");
   try {
     await handle.writeFile(value, "utf8");
@@ -170,7 +172,7 @@ async function writeTextFileExclusive(filePath, value) {
   }
 }
 async function writeBufferIfMissing(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   try {
     const handle = await promises.open(filePath, "wx");
     try {
@@ -204,7 +206,7 @@ function isAlreadyExistsError(error) {
   return error?.code === "EEXIST";
 }
 async function withFilesystemLock(lockPath, task) {
-  await ensureDirectory(path7__default.default.dirname(lockPath));
+  await ensureDirectory(path10__default.default.dirname(lockPath));
   let attempt = 0;
   while (true) {
     try {
@@ -259,8 +261,8 @@ async function readStructuredPayload(objectPath) {
 var FilesystemArtifactStore = class {
   constructor(rootPath) {
     this.rootPath = rootPath;
-    this.manifestsDirectory = path7__default.default.join(this.rootPath, "artifacts", "manifests");
-    this.objectsDirectory = path7__default.default.join(this.rootPath, "artifacts", "objects", "sha256");
+    this.manifestsDirectory = path10__default.default.join(this.rootPath, "artifacts", "manifests");
+    this.objectsDirectory = path10__default.default.join(this.rootPath, "artifacts", "objects", "sha256");
   }
   manifestsDirectory;
   objectsDirectory;
@@ -485,7 +487,7 @@ var FilesystemArtifactStore = class {
     }
   }
   manifestPath(artifactId) {
-    return path7__default.default.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
+    return path10__default.default.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
   }
 };
 function createArtifactStore(rootPath) {
@@ -580,31 +582,31 @@ function oneOfSchema(members, options = {}) {
 }
 
 // ../protocol/src/validation.ts
-function validateJsonSchema(schema, value, path15 = "$") {
-  return validateSchemaNode(schema, value, path15);
+function validateJsonSchema(schema, value, path18 = "$") {
+  return validateSchemaNode(schema, value, path18);
 }
-function validateSchemaNode(schema, value, path15) {
+function validateSchemaNode(schema, value, path18) {
   const issues = [];
   if ("const" in schema && !isJsonValueEqual(schema.const, value)) {
     issues.push({
-      path: path15,
+      path: path18,
       message: `must equal ${JSON.stringify(schema.const)}`
     });
     return issues;
   }
   if (schema.enum !== void 0 && !schema.enum.some((candidate) => isJsonValueEqual(candidate, value))) {
     issues.push({
-      path: path15,
+      path: path18,
       message: `must be one of ${schema.enum.map((candidate) => JSON.stringify(candidate)).join(", ")}`
     });
     return issues;
   }
   if (schema.oneOf !== void 0) {
-    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path15));
+    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path18));
     const validBranches = branchIssues.filter((current) => current.length === 0).length;
     if (validBranches !== 1) {
       issues.push({
-        path: path15,
+        path: path18,
         message: validBranches === 0 ? "must match exactly one supported shape" : "matches multiple supported shapes"
       });
       return issues;
@@ -612,11 +614,11 @@ function validateSchemaNode(schema, value, path15) {
   }
   if (schema.anyOf !== void 0) {
     const hasMatch = schema.anyOf.some(
-      (member) => validateSchemaNode(member, value, path15).length === 0
+      (member) => validateSchemaNode(member, value, path18).length === 0
     );
     if (!hasMatch) {
       issues.push({
-        path: path15,
+        path: path18,
         message: "must match at least one supported shape"
       });
       return issues;
@@ -624,7 +626,7 @@ function validateSchemaNode(schema, value, path15) {
   }
   if (schema.allOf !== void 0) {
     for (const member of schema.allOf) {
-      issues.push(...validateSchemaNode(member, value, path15));
+      issues.push(...validateSchemaNode(member, value, path18));
     }
     if (issues.length > 0) {
       return issues;
@@ -632,7 +634,7 @@ function validateSchemaNode(schema, value, path15) {
   }
   if (schema.type !== void 0 && !matchesSchemaType(schema.type, value)) {
     issues.push({
-      path: path15,
+      path: path18,
       message: `must be ${describeSchemaType(schema.type)}`
     });
     return issues;
@@ -640,19 +642,19 @@ function validateSchemaNode(schema, value, path15) {
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must have length >= ${String(schema.minLength)}`
       });
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must have length <= ${String(schema.maxLength)}`
       });
     }
     if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must match pattern ${schema.pattern}`
       });
     }
@@ -661,25 +663,25 @@ function validateSchemaNode(schema, value, path15) {
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must be >= ${String(schema.minimum)}`
       });
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must be <= ${String(schema.maximum)}`
       });
     }
     if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must be > ${String(schema.exclusiveMinimum)}`
       });
     }
     if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must be < ${String(schema.exclusiveMaximum)}`
       });
     }
@@ -688,13 +690,13 @@ function validateSchemaNode(schema, value, path15) {
   if (Array.isArray(value)) {
     if (schema.minItems !== void 0 && value.length < schema.minItems) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must have at least ${String(schema.minItems)} items`
       });
     }
     if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must have at most ${String(schema.maxItems)} items`
       });
     }
@@ -704,7 +706,7 @@ function validateSchemaNode(schema, value, path15) {
         const key = JSON.stringify(item);
         if (seen.has(key)) {
           issues.push({
-            path: path15,
+            path: path18,
             message: "must not contain duplicate items"
           });
           break;
@@ -714,7 +716,7 @@ function validateSchemaNode(schema, value, path15) {
     }
     if (schema.items !== void 0) {
       for (let index = 0; index < value.length; index += 1) {
-        issues.push(...validateSchemaNode(schema.items, value[index], `${path15}[${String(index)}]`));
+        issues.push(...validateSchemaNode(schema.items, value[index], `${path18}[${String(index)}]`));
       }
     }
     return issues;
@@ -724,7 +726,7 @@ function validateSchemaNode(schema, value, path15) {
     for (const requiredKey of schema.required ?? []) {
       if (!(requiredKey in value)) {
         issues.push({
-          path: joinObjectPath(path15, requiredKey),
+          path: joinObjectPath(path18, requiredKey),
           message: "is required"
         });
       }
@@ -733,13 +735,13 @@ function validateSchemaNode(schema, value, path15) {
       const propertySchema = properties[key];
       if (propertySchema !== void 0) {
         issues.push(
-          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path15, key))
+          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path18, key))
         );
         continue;
       }
       if (schema.additionalProperties === false) {
         issues.push({
-          path: joinObjectPath(path15, key),
+          path: joinObjectPath(path18, key),
           message: "is not allowed"
         });
         continue;
@@ -749,7 +751,7 @@ function validateSchemaNode(schema, value, path15) {
           ...validateSchemaNode(
             schema.additionalProperties,
             propertyValue,
-            joinObjectPath(path15, key)
+            joinObjectPath(path18, key)
           )
         );
       }
@@ -993,8 +995,8 @@ function matchesNetworkRecordFilters(record, filters) {
     }
   }
   if (filters.path !== void 0) {
-    const path15 = getParsedUrl().pathname;
-    if (!includesCaseInsensitive(path15, filters.path)) {
+    const path18 = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path18, filters.path)) {
       return false;
     }
   }
@@ -2507,7 +2509,7 @@ objectSchema(
   }
 );
 var opensteerSessionFetchTransportSchema = enumSchema(
-  ["auto", "direct", "matched-tls", "page"],
+  ["auto", "direct", "matched-tls", "context", "page"],
   {
     title: "OpensteerSessionFetchTransport"
   }
@@ -6860,6 +6862,7 @@ var opensteerSemanticOperationSpecificationsBase = [
         case "direct":
           return [];
         case "matched-tls":
+        case "context":
           return ["inspect.cookies"];
         case "page":
           return ["pages.manage"];
@@ -6991,9 +6994,9 @@ function compareByCreatedAtAndId(left, right) {
 var FilesystemRegistryStore = class {
   constructor(rootPath, registryRelativePath) {
     this.registryRelativePath = registryRelativePath;
-    const basePath = path7__default.default.join(rootPath, ...registryRelativePath);
-    this.recordsDirectory = path7__default.default.join(basePath, "records");
-    this.indexesDirectory = path7__default.default.join(basePath, "indexes", "by-key");
+    const basePath = path10__default.default.join(rootPath, ...registryRelativePath);
+    this.recordsDirectory = path10__default.default.join(basePath, "records");
+    this.indexesDirectory = path10__default.default.join(basePath, "indexes", "by-key");
   }
   recordsDirectory;
   indexesDirectory;
@@ -7062,7 +7065,7 @@ var FilesystemRegistryStore = class {
   async readRecordsFromDirectory() {
     const files = await listJsonFiles(this.recordsDirectory);
     const records = await Promise.all(
-      files.map((fileName) => readJsonFile(path7__default.default.join(this.recordsDirectory, fileName)))
+      files.map((fileName) => readJsonFile(path10__default.default.join(this.recordsDirectory, fileName)))
     );
     records.sort(compareByCreatedAtAndId);
     return records;
@@ -7094,17 +7097,17 @@ var FilesystemRegistryStore = class {
     return record;
   }
   recordPath(id) {
-    return path7__default.default.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
+    return path10__default.default.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
   }
   indexPath(key, version) {
-    return path7__default.default.join(
+    return path10__default.default.join(
       this.indexesDirectory,
       encodePathSegment(key),
       `${encodePathSegment(version)}.json`
     );
   }
   writeLockPath() {
-    return path7__default.default.join(path7__default.default.dirname(this.recordsDirectory), ".write.lock");
+    return path10__default.default.join(path10__default.default.dirname(this.recordsDirectory), ".write.lock");
   }
 };
 var FilesystemDescriptorRegistry = class extends FilesystemRegistryStore {
@@ -7474,20 +7477,13 @@ var SqliteSavedNetworkStore = class {
   directoryInitialization;
   databaseInitialization;
   constructor(rootPath) {
-    this.databasePath = path7__default.default.join(rootPath, "registry", "saved-network.sqlite");
+    this.databasePath = path10__default.default.join(rootPath, "registry", "saved-network.sqlite");
   }
   async initialize() {
     await this.ensureDatabaseDirectory();
   }
   async save(records, options) {
     const database = await this.requireDatabase();
-    const readExisting = database.prepare(`
-        SELECT record_id
-        FROM saved_network_records
-        WHERE session_ref = @session_ref
-          AND page_ref_key = @page_ref_key
-          AND request_id = @request_id
-      `);
     const upsertRecord = database.prepare(buildSavedNetworkUpsertSql(options.bodyWriteMode));
     const insertTag = database.prepare(`
       INSERT OR IGNORE INTO saved_network_tags (record_id, tag)
@@ -7498,14 +7494,8 @@ var SqliteSavedNetworkStore = class {
       for (const entry of records) {
         const url = new URL(entry.record.url);
         const pageRefKey = entry.record.pageRef ?? "";
-        const existing = readExisting.get({
-          session_ref: entry.record.sessionRef,
-          page_ref_key: pageRefKey,
-          request_id: entry.record.requestId
-        }) ?? void 0;
-        const recordId = existing?.record_id ?? entry.recordId;
         upsertRecord.run({
-          record_id: recordId,
+          record_id: entry.recordId,
           request_id: entry.record.requestId,
           session_ref: entry.record.sessionRef,
           page_ref: entry.record.pageRef ?? null,
@@ -7550,7 +7540,7 @@ var SqliteSavedNetworkStore = class {
         }
         for (const currentTag of tags) {
           const result = insertTag.run({
-            record_id: recordId,
+            record_id: entry.recordId,
             tag: currentTag
           });
           savedCount += result.changes ?? 0;
@@ -7653,6 +7643,49 @@ var SqliteSavedNetworkStore = class {
       return cleared;
     });
   }
+  async *iterateBatches(options = {}) {
+    const database = await this.requireDatabase();
+    const batchSize = Math.max(1, Math.min(options.batchSize ?? 500, 1e3));
+    let cursor;
+    while (true) {
+      const rows = database.prepare(
+        `
+      SELECT
+        r.*,
+        GROUP_CONCAT(t.tag, '${TAG_DELIMITER}') AS tags
+      FROM saved_network_records r
+      LEFT JOIN saved_network_tags t
+        ON t.record_id = r.record_id
+      ${cursor === void 0 ? "" : "WHERE r.saved_at > ? OR (r.saved_at = ? AND r.record_id > ?)"}
+      GROUP BY r.record_id
+      ORDER BY r.saved_at ASC, r.record_id ASC
+      LIMIT ?
+    `
+      ).all(
+        ...cursor === void 0 ? [] : [cursor.savedAt, cursor.savedAt, cursor.recordId],
+        batchSize
+      );
+      if (rows.length === 0) {
+        return;
+      }
+      yield rows.map((row) => inflateSavedNetworkRow(row, options.includeBodies ?? true));
+      const lastRow = rows.at(-1);
+      if (lastRow === void 0) {
+        return;
+      }
+      cursor = {
+        savedAt: lastRow.saved_at,
+        recordId: lastRow.record_id
+      };
+    }
+  }
+  close() {
+    if (this.database !== void 0) {
+      closeSqliteDatabase(this.database);
+      this.database = void 0;
+      this.databaseInitialization = void 0;
+    }
+  }
   async requireDatabase() {
     if (this.database) {
       return this.database;
@@ -7684,7 +7717,7 @@ var SqliteSavedNetworkStore = class {
     }
   }
   async ensureDatabaseDirectory() {
-    this.directoryInitialization ??= ensureDirectory(path7__default.default.dirname(this.databasePath)).catch(
+    this.directoryInitialization ??= ensureDirectory(path10__default.default.dirname(this.databasePath)).catch(
       (error) => {
         this.directoryInitialization = void 0;
         throw error;
@@ -7737,15 +7770,6 @@ var SqliteSavedNetworkStore = class {
         saved_at INTEGER NOT NULL
       );
 
-      CREATE UNIQUE INDEX IF NOT EXISTS saved_network_records_scope_request
-        ON saved_network_records (session_ref, page_ref_key, request_id);
-
-      CREATE INDEX IF NOT EXISTS saved_network_records_saved_at
-        ON saved_network_records (saved_at DESC);
-
-      CREATE INDEX IF NOT EXISTS saved_network_records_capture
-        ON saved_network_records (capture);
-
       CREATE TABLE IF NOT EXISTS saved_network_tags (
         record_id TEXT NOT NULL REFERENCES saved_network_records(record_id) ON DELETE CASCADE,
         tag TEXT NOT NULL,
@@ -7755,6 +7779,19 @@ var SqliteSavedNetworkStore = class {
       CREATE INDEX IF NOT EXISTS saved_network_tags_tag
         ON saved_network_tags (tag);
     `);
+    database.exec(`DROP INDEX IF EXISTS saved_network_records_scope_request`);
+    database.exec(`
+      CREATE INDEX IF NOT EXISTS saved_network_records_scope_request
+        ON saved_network_records (session_ref, page_ref_key, request_id)
+    `);
+    database.exec(`
+      CREATE INDEX IF NOT EXISTS saved_network_records_saved_at
+        ON saved_network_records (saved_at DESC)
+    `);
+    database.exec(`
+      CREATE INDEX IF NOT EXISTS saved_network_records_capture
+        ON saved_network_records (capture)
+    `);
     this.ensureColumn(
       database,
       "saved_network_records",
@@ -8279,7 +8316,7 @@ var FilesystemObservationStoreImpl = class {
   constructor(rootPath, artifacts) {
     this.rootPath = rootPath;
     this.artifacts = artifacts;
-    this.sessionsDirectory = path7__default.default.join(this.rootPath, "observations", "sessions");
+    this.sessionsDirectory = path10__default.default.join(this.rootPath, "observations", "sessions");
   }
   sessionsDirectory;
   redactors = /* @__PURE__ */ new Map();
@@ -8376,7 +8413,7 @@ var FilesystemObservationStoreImpl = class {
           ...raw.artifactIds === void 0 || raw.artifactIds.length === 0 ? {} : { artifactIds: [...raw.artifactIds] }
         };
         await writeJsonFileExclusive(
-          path7__default.default.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
+          path10__default.default.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
           event
         );
         updatedAt = Math.max(updatedAt, createdAt);
@@ -8434,7 +8471,7 @@ var FilesystemObservationStoreImpl = class {
     }
     const files = await listJsonFiles(directoryPath);
     const events = await Promise.all(
-      files.map((fileName) => readJsonFile(path7__default.default.join(directoryPath, fileName)))
+      files.map((fileName) => readJsonFile(path10__default.default.join(directoryPath, fileName)))
     );
     const filtered = events.filter((event) => {
       if (input.kind !== void 0 && event.kind !== input.kind) return false;
@@ -8461,7 +8498,7 @@ var FilesystemObservationStoreImpl = class {
     const files = await listJsonFiles(directoryPath);
     const artifacts = await Promise.all(
       files.map(
-        (fileName) => readJsonFile(path7__default.default.join(directoryPath, fileName))
+        (fileName) => readJsonFile(path10__default.default.join(directoryPath, fileName))
       )
     );
     const filtered = artifacts.filter((artifact) => {
@@ -8524,25 +8561,25 @@ var FilesystemObservationStoreImpl = class {
     )).filter((value) => value !== void 0);
   }
   sessionDirectory(sessionId) {
-    return path7__default.default.join(this.sessionsDirectory, encodePathSegment(sessionId));
+    return path10__default.default.join(this.sessionsDirectory, encodePathSegment(sessionId));
   }
   sessionManifestPath(sessionId) {
-    return path7__default.default.join(this.sessionDirectory(sessionId), "session.json");
+    return path10__default.default.join(this.sessionDirectory(sessionId), "session.json");
   }
   sessionEventsDirectory(sessionId) {
-    return path7__default.default.join(this.sessionDirectory(sessionId), "events");
+    return path10__default.default.join(this.sessionDirectory(sessionId), "events");
   }
   sessionArtifactsDirectory(sessionId) {
-    return path7__default.default.join(this.sessionDirectory(sessionId), "artifacts");
+    return path10__default.default.join(this.sessionDirectory(sessionId), "artifacts");
   }
   sessionArtifactPath(sessionId, artifactId) {
-    return path7__default.default.join(
+    return path10__default.default.join(
       this.sessionArtifactsDirectory(sessionId),
       `${encodePathSegment(artifactId)}.json`
     );
   }
   sessionLockPath(sessionId) {
-    return path7__default.default.join(this.sessionDirectory(sessionId), ".lock");
+    return path10__default.default.join(this.sessionDirectory(sessionId), ".lock");
   }
   async reconcileSessionManifest(sessionId) {
     const session = await this.getSession(sessionId);
@@ -8570,14 +8607,14 @@ var FilesystemObservationStoreImpl = class {
       Promise.all(
         eventFiles.map(
           (fileName) => readJsonFile(
-            path7__default.default.join(this.sessionEventsDirectory(sessionId), fileName)
+            path10__default.default.join(this.sessionEventsDirectory(sessionId), fileName)
           )
         )
       ),
       Promise.all(
         artifactFiles.map(
           (fileName) => readJsonFile(
-            path7__default.default.join(this.sessionArtifactsDirectory(sessionId), fileName)
+            path10__default.default.join(this.sessionArtifactsDirectory(sessionId), fileName)
           )
         )
       )
@@ -8630,7 +8667,7 @@ var FilesystemTraceStore = class {
   constructor(rootPath, artifacts) {
     this.rootPath = rootPath;
     this.artifacts = artifacts;
-    this.runsDirectory = path7__default.default.join(this.rootPath, "traces", "runs");
+    this.runsDirectory = path10__default.default.join(this.rootPath, "traces", "runs");
   }
   runsDirectory;
   async initialize() {
@@ -8707,7 +8744,7 @@ var FilesystemTraceStore = class {
         ...input.error === void 0 ? {} : { error: input.error }
       };
       await writeJsonFileExclusive(
-        path7__default.default.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
+        path10__default.default.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
         entry
       );
       await writeJsonFileAtomic(this.runManifestPath(runId), {
@@ -8726,7 +8763,7 @@ var FilesystemTraceStore = class {
     const files = await listJsonFiles(entriesDirectory);
     return Promise.all(
       files.map(
-        (fileName) => readJsonFile(path7__default.default.join(entriesDirectory, fileName))
+        (fileName) => readJsonFile(path10__default.default.join(entriesDirectory, fileName))
       )
     );
   }
@@ -8772,16 +8809,16 @@ var FilesystemTraceStore = class {
     return { trace, artifacts };
   }
   runDirectory(runId) {
-    return path7__default.default.join(this.runsDirectory, encodeURIComponent(runId));
+    return path10__default.default.join(this.runsDirectory, encodeURIComponent(runId));
   }
   runEntriesDirectory(runId) {
-    return path7__default.default.join(this.runDirectory(runId), "entries");
+    return path10__default.default.join(this.runDirectory(runId), "entries");
   }
   runManifestPath(runId) {
-    return path7__default.default.join(this.runDirectory(runId), "manifest.json");
+    return path10__default.default.join(this.runDirectory(runId), "manifest.json");
   }
   runWriteLockPath(runId) {
-    return path7__default.default.join(this.runDirectory(runId), ".append.lock");
+    return path10__default.default.join(this.runDirectory(runId), ".append.lock");
   }
 };
 function createTraceStore(rootPath, artifacts) {
@@ -8795,7 +8832,7 @@ function normalizeWorkspaceId(workspace) {
   return encodePathSegment(workspace);
 }
 function resolveFilesystemWorkspacePath(input) {
-  return path7__default.default.join(
+  return path10__default.default.join(
     input.rootDir,
     ".opensteer",
     "workspaces",
@@ -8804,18 +8841,18 @@ function resolveFilesystemWorkspacePath(input) {
 }
 async function createFilesystemOpensteerWorkspace(options) {
   await ensureDirectory(options.rootPath);
-  const manifestPath = path7__default.default.join(options.rootPath, "workspace.json");
-  const browserPath = path7__default.default.join(options.rootPath, "browser");
-  const browserManifestPath = path7__default.default.join(browserPath, "manifest.json");
-  const browserUserDataDir = path7__default.default.join(browserPath, "user-data");
-  const livePath = path7__default.default.join(options.rootPath, "live");
-  const liveLocalPath = path7__default.default.join(livePath, "local.json");
-  const liveCloudPath = path7__default.default.join(livePath, "cloud.json");
-  const artifactsPath = path7__default.default.join(options.rootPath, "artifacts");
-  const tracesPath = path7__default.default.join(options.rootPath, "traces");
-  const observationsPath = path7__default.default.join(options.rootPath, "observations");
-  const registryPath = path7__default.default.join(options.rootPath, "registry");
-  const lockPath = path7__default.default.join(options.rootPath, ".lock");
+  const manifestPath = path10__default.default.join(options.rootPath, "workspace.json");
+  const browserPath = path10__default.default.join(options.rootPath, "browser");
+  const browserManifestPath = path10__default.default.join(browserPath, "manifest.json");
+  const browserUserDataDir = path10__default.default.join(browserPath, "user-data");
+  const livePath = path10__default.default.join(options.rootPath, "live");
+  const liveLocalPath = path10__default.default.join(livePath, "local.json");
+  const liveCloudPath = path10__default.default.join(livePath, "cloud.json");
+  const artifactsPath = path10__default.default.join(options.rootPath, "artifacts");
+  const tracesPath = path10__default.default.join(options.rootPath, "traces");
+  const observationsPath = path10__default.default.join(options.rootPath, "observations");
+  const registryPath = path10__default.default.join(options.rootPath, "registry");
+  const lockPath = path10__default.default.join(options.rootPath, ".lock");
   let manifest;
   if (await pathExists(manifestPath)) {
     manifest = await readJsonFile(manifestPath);
@@ -8942,7 +8979,6 @@ var DEFAULT_TIMEOUTS = {
   "dom.extract": 15e3,
   "network.query": 15e3,
   "network.detail": 15e3,
-  "network.replay": 3e4,
   "scripts.capture": 15e3,
   "session.cookies": 1e4,
   "session.storage": 1e4,
@@ -9571,9 +9607,9 @@ var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "poster",
   "ping"
 ]);
-function buildArrayFieldPathCandidates(path15) {
-  const strict = path15.nodes.length ? buildPathCandidates(path15.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path15.nodes);
+function buildArrayFieldPathCandidates(path18) {
+  const strict = path18.nodes.length ? buildPathCandidates(path18.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path18.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -10103,18 +10139,18 @@ function cloneStructuralElementAnchor(anchor) {
     nodes: anchor.nodes.map(clonePathNode)
   };
 }
-function cloneReplayElementPath(path15) {
+function cloneReplayElementPath(path18) {
   return {
     resolution: "deterministic",
-    context: cloneContext(path15.context),
-    nodes: path15.nodes.map(clonePathNode)
+    context: cloneContext(path18.context),
+    nodes: path18.nodes.map(clonePathNode)
   };
 }
-function cloneElementPath(path15) {
-  return cloneReplayElementPath(path15);
+function cloneElementPath(path18) {
+  return cloneReplayElementPath(path18);
 }
-function buildPathSelectorHint(path15) {
-  const nodes = path15?.nodes || [];
+function buildPathSelectorHint(path18) {
+  const nodes = path18?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) {
     return "*";
@@ -10163,15 +10199,15 @@ function sanitizeStructuralElementAnchor(anchor) {
     nodes: sanitizeNodes(anchor.nodes)
   };
 }
-function sanitizeReplayElementPath(path15) {
+function sanitizeReplayElementPath(path18) {
   return {
     resolution: "deterministic",
-    context: sanitizeContext(path15.context),
-    nodes: sanitizeNodes(path15.nodes)
+    context: sanitizeContext(path18.context),
+    nodes: sanitizeNodes(path18.nodes)
   };
 }
-function sanitizeElementPath(path15) {
-  return sanitizeReplayElementPath(path15);
+function sanitizeElementPath(path18) {
+  return sanitizeReplayElementPath(path18);
 }
 function buildLocalStructuralElementAnchor(index, rawTargetNode) {
   const targetNode = requireElementNode(index, rawTargetNode);
@@ -10294,8 +10330,8 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
   }
   return `${base} Target depth ${String(depth)}. Candidate counts: ${sample}.`;
 }
-function buildArrayFieldCandidates(path15) {
-  return buildArrayFieldPathCandidates(path15);
+function buildArrayFieldCandidates(path18) {
+  return buildArrayFieldPathCandidates(path18);
 }
 function firstDefinedAttribute(node, keys) {
   for (const key of keys) {
@@ -11831,21 +11867,21 @@ var DefaultDomRuntime = class {
     return match;
   }
   async resolvePathTarget(session, pageRef, rawPath, source, persist, descriptor) {
-    const path15 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path15.context);
-    const target = resolveDomPathInScope(context.index, path15.nodes, context.scope);
+    const path18 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path18.context);
+    const target = resolveDomPathInScope(context.index, path18.nodes, context.scope);
     if (!target) {
-      throwTargetNotFound(context.index, path15.nodes, context.scope);
+      throwTargetNotFound(context.index, path18.nodes, context.scope);
     }
     if (target.node.nodeRef === void 0) {
       throw new Error(
-        `resolved path "${buildPathSelectorHint(path15)}" does not point to a live element`
+        `resolved path "${buildPathSelectorHint(path18)}" does not point to a live element`
       );
     }
     const anchor = await this.buildAnchorFromSnapshotNode(session, context.snapshot, target.node);
     return this.createResolvedTarget(source, context.snapshot, target.node, anchor, {
       ...persist === void 0 ? {} : { persist },
-      replayPath: path15,
+      replayPath: path18,
       ...source === "path" || source === "descriptor" ? { selectorUsed: target.selector } : {},
       ...descriptor === void 0 ? {} : { descriptor }
     });
@@ -11866,9 +11902,9 @@ var DefaultDomRuntime = class {
     });
   }
   async queryAllByElementPath(session, pageRef, rawPath) {
-    const path15 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path15.context);
-    return queryAllDomPathInScope(context.index, path15.nodes, context.scope).filter(
+    const path18 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path18.context);
+    return queryAllDomPathInScope(context.index, path18.nodes, context.scope).filter(
       (node) => node.nodeRef !== void 0
     ).map((node) => this.createSnapshotTarget(context.snapshot, node));
   }
@@ -12054,16 +12090,16 @@ var DefaultDomRuntime = class {
     const index = createSnapshotIndex(item.snapshot);
     return this.resolveFirstArrayFieldTargetInNode(index, item.node, field.path);
   }
-  resolveFirstArrayFieldTargetInNode(index, rootNode, path15) {
-    const normalizedPath = sanitizeElementPath(path15);
+  resolveFirstArrayFieldTargetInNode(index, rootNode, path18) {
+    const normalizedPath = sanitizeElementPath(path18);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
     }
     return resolveFirstWithinNodeBySelectors(index, rootNode, selectors);
   }
-  resolveUniqueArrayFieldTargetInNode(index, rootNode, path15) {
-    const normalizedPath = sanitizeElementPath(path15);
+  resolveUniqueArrayFieldTargetInNode(index, rootNode, path18) {
+    const normalizedPath = sanitizeElementPath(path18);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
@@ -12152,8 +12188,8 @@ function encodeDataPath(tokens) {
   }
   return out;
 }
-function parseDataPath(path15) {
-  const input = path15.trim();
+function parseDataPath(path18) {
+  const input = path18.trim();
   if (input.length === 0) {
     return [];
   }
@@ -12203,8 +12239,8 @@ function parseDataPath(path15) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path15, value] of Object.entries(flat)) {
-    const tokens = parseDataPath(path15);
+  for (const [path18, value] of Object.entries(flat)) {
+    const tokens = parseDataPath(path18);
     if (!tokens || tokens.length === 0) {
       continue;
     }
@@ -12536,8 +12572,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path15, mode) {
-  const normalized = sanitizeElementPath(path15);
+function minimizePathMatchClauses(path18, mode) {
+  const normalized = sanitizeElementPath(path18);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -12641,8 +12677,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path15, mode) {
-  const normalized = sanitizeElementPath(path15);
+function relaxPathForSingleSample(path18, mode) {
+  const normalized = sanitizeElementPath(path18);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -12727,8 +12763,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path15) {
-  const normalized = sanitizeElementPath(path15);
+function buildPathStructureKey(path18) {
+  const normalized = sanitizeElementPath(path18);
   return canonicalJsonString({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -12855,30 +12891,30 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path15, node) {
-  const tokens = parseDataPath(path15);
+function insertNodeAtPath(root, path18, node) {
+  const tokens = parseDataPath(path18);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path15}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path18}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path15}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path18}": nested array indices are not supported in cached descriptors.`
     );
   }
   let current = root;
   for (let index = 0; index < tokens.length; index += 1) {
     const token = tokens[index];
     if (!token || token.kind !== "prop") {
-      throw new Error(`Invalid persisted extraction path "${path15}": expected object segment.`);
+      throw new Error(`Invalid persisted extraction path "${path18}": expected object segment.`);
     }
     const isLast = index === tokens.length - 1;
     if (isLast) {
       const existing = current[token.key];
       if (existing) {
         throw new Error(
-          `Conflicting persisted extraction path "${path15}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path18}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -12893,7 +12929,7 @@ function insertNodeAtPath(root, path15, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path15}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path18}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -12928,7 +12964,7 @@ function buildItemRootForArrayIndex(entries) {
   }
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path15) => path15 !== null);
+  ).filter((path18) => path18 !== null);
   if (!paths.length) {
     return null;
   }
@@ -12949,7 +12985,7 @@ function getCommonPathPrefixLength(paths) {
   if (!paths.length) {
     return 0;
   }
-  const nodeChains = paths.map((path15) => path15.nodes);
+  const nodeChains = paths.map((path18) => path18.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) {
     return 0;
@@ -13018,30 +13054,30 @@ function mergeElementPathsByMajority(paths) {
   if (!paths.length) {
     return null;
   }
-  const normalized = paths.map((path15) => sanitizeElementPath(path15));
+  const normalized = paths.map((path18) => sanitizeElementPath(path18));
   const contextKey = pickModeString(
-    normalized.map((path15) => canonicalJsonString(path15.context)),
+    normalized.map((path18) => canonicalJsonString(path18.context)),
     1
   );
   if (!contextKey) {
     return null;
   }
-  const sameContext = normalized.filter((path15) => canonicalJsonString(path15.context) === contextKey);
+  const sameContext = normalized.filter((path18) => canonicalJsonString(path18.context) === contextKey);
   if (!sameContext.length) {
     return null;
   }
   const targetLength = pickModeNumber(
-    sameContext.map((path15) => path15.nodes.length),
+    sameContext.map((path18) => path18.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
-  const aligned = sameContext.filter((path15) => path15.nodes.length === targetLength);
+  const aligned = sameContext.filter((path18) => path18.nodes.length === targetLength);
   if (!aligned.length) {
     return null;
   }
   const threshold = majorityThreshold(aligned.length);
   const nodes = [];
   for (let index = 0; index < targetLength; index += 1) {
-    const nodesAtIndex = aligned.map((path15) => path15.nodes[index]).filter((node) => node !== void 0);
+    const nodesAtIndex = aligned.map((path18) => path18.nodes[index]).filter((node) => node !== void 0);
     if (!nodesAtIndex.length) {
       return null;
     }
@@ -13287,8 +13323,8 @@ function clonePathContext(context) {
 function clonePathNodes(nodes) {
   return JSON.parse(JSON.stringify(nodes || []));
 }
-function cloneElementPath2(path15) {
-  return JSON.parse(JSON.stringify(path15));
+function cloneElementPath2(path18) {
+  return JSON.parse(JSON.stringify(path18));
 }
 function clonePersistedOpensteerExtractionNode(node) {
   return JSON.parse(JSON.stringify(node));
@@ -13606,8 +13642,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path15) => {
-          node.$path = sanitizeElementPath(path15);
+        replacePath: (path18) => {
+          node.$path = sanitizeElementPath(path18);
         }
       }
     ];
@@ -13621,13 +13657,13 @@ function collectPersistedValueNodeRefs(node) {
   }
   return refs;
 }
-function hasPositionClause(path15) {
-  return path15.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
+function hasPositionClause(path18) {
+  return path18.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
 }
-function stripPositionClauses2(path15) {
+function stripPositionClauses2(path18) {
   return sanitizeElementPath({
-    context: path15.context,
-    nodes: path15.nodes.map((node) => ({
+    context: path18.context,
+    nodes: path18.nodes.map((node) => ({
       ...node,
       match: node.match.filter((clause) => clause.kind !== "position")
     }))
@@ -14037,17 +14073,57 @@ function normalizeNonEmptyString2(name, value) {
 function normalizeKey(value) {
   return String(value ?? "").trim();
 }
-function labelForPath(path15) {
-  return path15.trim().length === 0 ? "$" : path15;
+function labelForPath(path18) {
+  return path18.trim().length === 0 ? "$" : path18;
 }
 function sha256Hex3(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
-util.promisify(child_process.execFile);
-Math.floor(Date.now() - process.uptime() * 1e3);
-({ ...process.env});
-({
-  pid: process.pid});
+var execFileAsync = util.promisify(child_process.execFile);
+var PROCESS_STARTED_AT_MS = Math.floor(Date.now() - process.uptime() * 1e3);
+var PROCESS_START_TIME_TOLERANCE_MS = 1e3;
+var PROCESS_LIST_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+var PS_COMMAND_ENV = { ...process.env, LC_ALL: "C" };
+var LINUX_STAT_START_TIME_FIELD_INDEX = 19;
+var CURRENT_PROCESS_OWNER = {
+  pid: process.pid,
+  processStartedAtMs: PROCESS_STARTED_AT_MS
+};
+var linuxClockTicksPerSecondPromise = null;
+function parseProcessOwner(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const pid = Number(parsed.pid);
+  const processStartedAtMs = Number(parsed.processStartedAtMs);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
+    return null;
+  }
+  return {
+    pid,
+    processStartedAtMs
+  };
+}
+function processOwnersEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.pid === right.pid && left.processStartedAtMs === right.processStartedAtMs;
+}
+async function getProcessLiveness(owner) {
+  if (owner.pid === process.pid && hasMatchingProcessStartTime(owner.processStartedAtMs, PROCESS_STARTED_AT_MS)) {
+    return "live";
+  }
+  const startedAtMs = await readProcessStartedAtMs(owner.pid);
+  if (typeof startedAtMs === "number") {
+    return hasMatchingProcessStartTime(owner.processStartedAtMs, startedAtMs) ? "live" : "dead";
+  }
+  return isProcessRunning(owner.pid) ? "unknown" : "dead";
+}
 function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
@@ -14057,6 +14133,116 @@ function isProcessRunning(pid) {
     return code !== "ESRCH";
   }
 }
+function hasMatchingProcessStartTime(expectedStartedAtMs, actualStartedAtMs) {
+  return Math.abs(expectedStartedAtMs - actualStartedAtMs) <= PROCESS_START_TIME_TOLERANCE_MS;
+}
+async function readProcessStartedAtMs(pid) {
+  if (pid <= 0) {
+    return null;
+  }
+  if (process.platform === "linux") {
+    return readLinuxProcessStartedAtMs(pid);
+  }
+  if (process.platform === "win32") {
+    return readWindowsProcessStartedAtMs(pid);
+  }
+  return readPsProcessStartedAtMs(pid);
+}
+async function readLinuxProcessStartedAtMs(pid) {
+  let statRaw;
+  try {
+    statRaw = await promises.readFile(`/proc/${String(pid)}/stat`, "utf8");
+  } catch {
+    return null;
+  }
+  const startTicks = parseLinuxProcessStartTicks(statRaw);
+  if (startTicks === null) {
+    return null;
+  }
+  const [bootTimeMs, clockTicksPerSecond] = await Promise.all([
+    readLinuxBootTimeMs(),
+    readLinuxClockTicksPerSecond()
+  ]);
+  if (bootTimeMs === null || clockTicksPerSecond === null) {
+    return null;
+  }
+  return Math.floor(bootTimeMs + startTicks * 1e3 / clockTicksPerSecond);
+}
+function parseLinuxProcessStartTicks(statRaw) {
+  const closingParenIndex = statRaw.lastIndexOf(")");
+  if (closingParenIndex === -1) {
+    return null;
+  }
+  const fields = statRaw.slice(closingParenIndex + 2).trim().split(/\s+/);
+  const startTicks = Number(fields[LINUX_STAT_START_TIME_FIELD_INDEX]);
+  return Number.isFinite(startTicks) && startTicks >= 0 ? startTicks : null;
+}
+async function readLinuxBootTimeMs() {
+  try {
+    const statRaw = await promises.readFile("/proc/stat", "utf8");
+    const bootTimeLine = statRaw.split("\n").find((line) => line.startsWith("btime "));
+    if (!bootTimeLine) {
+      return null;
+    }
+    const bootTimeSeconds = Number.parseInt(bootTimeLine.slice("btime ".length), 10);
+    return Number.isFinite(bootTimeSeconds) ? bootTimeSeconds * 1e3 : null;
+  } catch {
+    return null;
+  }
+}
+async function readLinuxClockTicksPerSecond() {
+  if (!linuxClockTicksPerSecondPromise) {
+    linuxClockTicksPerSecondPromise = execFileAsync("getconf", ["CLK_TCK"], {
+      encoding: "utf8",
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+    }).then(({ stdout }) => {
+      const value = Number.parseInt(stdout.trim(), 10);
+      return Number.isFinite(value) && value > 0 ? value : null;
+    }).catch(() => null);
+  }
+  return linuxClockTicksPerSecondPromise;
+}
+async function readWindowsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Get-Process -Id ${String(pid)}).StartTime.ToUniversalTime().ToString("o")`
+      ],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+      }
+    );
+    const isoTimestamp = stdout.trim();
+    if (!isoTimestamp) {
+      return null;
+    }
+    const startedAtMs = Date.parse(isoTimestamp);
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+async function readPsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      env: PS_COMMAND_ENV,
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+    });
+    const startedAt = stdout.trim();
+    if (!startedAt) {
+      return null;
+    }
+    const startedAtMs = Date.parse(startedAt.replace(/\s+/g, " "));
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
 var CHROME_SINGLETON_ARTIFACTS = [
   "SingletonCookie",
   "SingletonLock",
@@ -14067,7 +14253,7 @@ var CHROME_SINGLETON_ARTIFACTS = [
 async function clearChromeSingletonEntries(userDataDir) {
   await Promise.all(
     CHROME_SINGLETON_ARTIFACTS.map(
-      (entry) => promises.rm(path7.join(userDataDir, entry), {
+      (entry) => promises.rm(path10.join(userDataDir, entry), {
         recursive: true,
         force: true
       }).catch(() => void 0)
@@ -14082,7 +14268,7 @@ async function sanitizeChromeProfile(userDataDir) {
   await Promise.all(profileDirs.map((dir) => sanitizeProfilePreferences(userDataDir, dir)));
 }
 async function sanitizeProfilePreferences(userDataDir, profileDir) {
-  const prefsPath = path7.join(userDataDir, profileDir, "Preferences");
+  const prefsPath = path10.join(userDataDir, profileDir, "Preferences");
   try {
     const raw = await promises.readFile(prefsPath, "utf8");
     const prefs = JSON.parse(raw);
@@ -14094,7 +14280,7 @@ async function sanitizeProfilePreferences(userDataDir, profileDir) {
     profile.exited_cleanly = true;
     prefs.profile = profile;
     await promises.writeFile(prefsPath, JSON.stringify(prefs), "utf8");
-    await promises.rm(path7.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
+    await promises.rm(path10.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
       () => void 0
     );
   } catch {
@@ -14115,9 +14301,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "Google", "Chrome", "Application", "chrome.exe"),
-        path7.join(WINDOWS_PROGRAM_FILES_X86, "Google", "Chrome", "Application", "chrome.exe"),
-        path7.join("~", "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe")
+        path10.join(WINDOWS_PROGRAM_FILES, "Google", "Chrome", "Application", "chrome.exe"),
+        path10.join(WINDOWS_PROGRAM_FILES_X86, "Google", "Chrome", "Application", "chrome.exe"),
+        path10.join("~", "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe")
       ],
       userDataDir: "~/AppData/Local/Google/Chrome/User Data",
       processNames: ["/google/chrome/application/chrome.exe"]
@@ -14147,7 +14333,7 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
+        path10.join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
       ],
       userDataDir: "~/AppData/Local/Google/Chrome SxS/User Data",
       processNames: ["/google/chrome sxs/application/chrome.exe"]
@@ -14164,9 +14350,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "Chromium", "Application", "chrome.exe"),
-        path7.join(WINDOWS_PROGRAM_FILES_X86, "Chromium", "Application", "chrome.exe"),
-        path7.join("~", "AppData", "Local", "Chromium", "Application", "chrome.exe")
+        path10.join(WINDOWS_PROGRAM_FILES, "Chromium", "Application", "chrome.exe"),
+        path10.join(WINDOWS_PROGRAM_FILES_X86, "Chromium", "Application", "chrome.exe"),
+        path10.join("~", "AppData", "Local", "Chromium", "Application", "chrome.exe")
       ],
       userDataDir: "~/AppData/Local/Chromium/User Data",
       processNames: ["/chromium/application/chrome.exe"]
@@ -14193,15 +14379,15 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
-        path7.join(
+        path10.join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+        path10.join(
           WINDOWS_PROGRAM_FILES_X86,
           "BraveSoftware",
           "Brave-Browser",
           "Application",
           "brave.exe"
         ),
-        path7.join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
+        path10.join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
       ],
       userDataDir: "~/AppData/Local/BraveSoftware/Brave-Browser/User Data",
       processNames: ["/bravesoftware/brave-browser/application/brave.exe"]
@@ -14227,9 +14413,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "Microsoft", "Edge", "Application", "msedge.exe"),
-        path7.join(WINDOWS_PROGRAM_FILES_X86, "Microsoft", "Edge", "Application", "msedge.exe"),
-        path7.join("~", "AppData", "Local", "Microsoft", "Edge", "Application", "msedge.exe")
+        path10.join(WINDOWS_PROGRAM_FILES, "Microsoft", "Edge", "Application", "msedge.exe"),
+        path10.join(WINDOWS_PROGRAM_FILES_X86, "Microsoft", "Edge", "Application", "msedge.exe"),
+        path10.join("~", "AppData", "Local", "Microsoft", "Edge", "Application", "msedge.exe")
       ],
       userDataDir: "~/AppData/Local/Microsoft/Edge/User Data",
       processNames: ["/microsoft/edge/application/msedge.exe"]
@@ -14257,9 +14443,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "Vivaldi", "Application", "vivaldi.exe"),
-        path7.join(WINDOWS_PROGRAM_FILES_X86, "Vivaldi", "Application", "vivaldi.exe"),
-        path7.join("~", "AppData", "Local", "Vivaldi", "Application", "vivaldi.exe")
+        path10.join(WINDOWS_PROGRAM_FILES, "Vivaldi", "Application", "vivaldi.exe"),
+        path10.join(WINDOWS_PROGRAM_FILES_X86, "Vivaldi", "Application", "vivaldi.exe"),
+        path10.join("~", "AppData", "Local", "Vivaldi", "Application", "vivaldi.exe")
       ],
       userDataDir: "~/AppData/Local/Vivaldi/User Data",
       processNames: ["/vivaldi/application/vivaldi.exe"]
@@ -14323,35 +14509,35 @@ function detectInstalledBrowserBrands() {
       brandId: brand2.id,
       displayName: brand2.displayName,
       executablePath,
-      userDataDir: path7.resolve(expandHome(platformConfig.userDataDir))
+      userDataDir: path10.resolve(expandHome(platformConfig.userDataDir))
     });
   }
   return installations;
 }
 function resolveBrandUserDataDir(brand2, explicitDir) {
   if (explicitDir !== void 0) {
-    return path7.resolve(expandHome(explicitDir));
+    return path10.resolve(expandHome(explicitDir));
   }
   const platformConfig = resolveBrandPlatformConfig(brand2);
   if (!platformConfig) {
     throw new Error(`${brand2.displayName} is not supported on ${process.platform}.`);
   }
-  return path7.resolve(expandHome(platformConfig.userDataDir));
+  return path10.resolve(expandHome(platformConfig.userDataDir));
 }
 function resolveExecutableCandidates(candidates) {
-  return candidates.map((candidate) => candidate ? path7.resolve(expandHome(candidate)) : null);
+  return candidates.map((candidate) => candidate ? path10.resolve(expandHome(candidate)) : null);
 }
 
 // src/local-browser/chrome-discovery.ts
 function expandHome(value) {
   if (value === "~" || value.startsWith("~/")) {
-    return path7.join(os.homedir(), value.slice(1));
+    return path10.join(os.homedir(), value.slice(1));
   }
   return value;
 }
 function resolveChromeUserDataDir(userDataDir) {
   const installation = detectLocalChromeInstallations().find(
-    (candidate) => fs.existsSync(path7.join(candidate.userDataDir, "Local State")) || candidate.executablePath !== null
+    (candidate) => fs.existsSync(path10.join(candidate.userDataDir, "Local State")) || candidate.executablePath !== null
   );
   if (!installation) {
     throw new Error("Could not find a local Chrome or Chromium profile directory.");
@@ -14360,7 +14546,7 @@ function resolveChromeUserDataDir(userDataDir) {
 }
 function resolveChromeExecutablePath(executablePath) {
   if (executablePath !== void 0) {
-    const resolvedPath = path7.resolve(expandHome(executablePath));
+    const resolvedPath = path10.resolve(expandHome(executablePath));
     if (!fs.existsSync(resolvedPath)) {
       throw new Error(`Chrome executable was not found at "${resolvedPath}".`);
     }
@@ -14384,37 +14570,37 @@ function detectLocalChromeInstallations() {
           "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
           "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
         ]),
-        userDataDir: path7.join(os.homedir(), "Library", "Application Support", "Google", "Chrome")
+        userDataDir: path10.join(os.homedir(), "Library", "Application Support", "Google", "Chrome")
       },
       {
         brand: "chromium",
         executablePath: firstExistingPath(["/Applications/Chromium.app/Contents/MacOS/Chromium"]),
-        userDataDir: path7.join(os.homedir(), "Library", "Application Support", "Chromium")
+        userDataDir: path10.join(os.homedir(), "Library", "Application Support", "Chromium")
       }
     ];
   }
   if (process.platform === "win32") {
     const programFiles = process.env.PROGRAMFILES ?? "C:\\Program Files";
     const programFilesX86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
-    const localAppData = process.env.LOCALAPPDATA ?? path7.join(os.homedir(), "AppData", "Local");
+    const localAppData = process.env.LOCALAPPDATA ?? path10.join(os.homedir(), "AppData", "Local");
     return [
       {
         brand: "chrome",
         executablePath: firstExistingPath([
-          path7.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
-          path7.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
-          path7.join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
+          path10.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+          path10.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+          path10.join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
         ]),
-        userDataDir: path7.join(localAppData, "Google", "Chrome", "User Data")
+        userDataDir: path10.join(localAppData, "Google", "Chrome", "User Data")
       },
       {
         brand: "chromium",
         executablePath: firstExistingPath([
-          path7.join(programFiles, "Chromium", "Application", "chrome.exe"),
-          path7.join(programFilesX86, "Chromium", "Application", "chrome.exe"),
-          path7.join(localAppData, "Chromium", "Application", "chrome.exe")
+          path10.join(programFiles, "Chromium", "Application", "chrome.exe"),
+          path10.join(programFilesX86, "Chromium", "Application", "chrome.exe"),
+          path10.join(localAppData, "Chromium", "Application", "chrome.exe")
         ]),
-        userDataDir: path7.join(localAppData, "Chromium", "User Data")
+        userDataDir: path10.join(localAppData, "Chromium", "User Data")
       }
     ];
   }
@@ -14427,7 +14613,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("google-chrome"),
         resolveBinaryFromPath("google-chrome-stable")
       ]),
-      userDataDir: path7.join(os.homedir(), ".config", "google-chrome")
+      userDataDir: path10.join(os.homedir(), ".config", "google-chrome")
     },
     {
       brand: "chromium",
@@ -14437,7 +14623,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("chromium"),
         resolveBinaryFromPath("chromium-browser")
       ]),
-      userDataDir: path7.join(os.homedir(), ".config", "chromium")
+      userDataDir: path10.join(os.homedir(), ".config", "chromium")
     }
   ];
 }
@@ -14449,8 +14635,8 @@ function detectLocalBrowserInstallations() {
   }));
 }
 function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
-  const resolvedUserDataDir = path7.resolve(expandHome(userDataDir));
-  const localStatePath = path7.join(resolvedUserDataDir, "Local State");
+  const resolvedUserDataDir = path10.resolve(expandHome(userDataDir));
+  const localStatePath = path10.join(resolvedUserDataDir, "Local State");
   if (!fs.existsSync(localStatePath)) {
     return [];
   }
@@ -14462,7 +14648,7 @@ function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
     }
     return Object.entries(infoCache).map(([directory, info]) => {
       const record = info && typeof info === "object" && !Array.isArray(info) ? info : {};
-      const name = typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : directory || path7.basename(directory);
+      const name = typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : directory || path10.basename(directory);
       return {
         directory,
         name,
@@ -14474,7 +14660,7 @@ function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
   }
 }
 function readDevToolsActivePort(userDataDir) {
-  const devToolsPath = path7.join(userDataDir, "DevToolsActivePort");
+  const devToolsPath = path10.join(userDataDir, "DevToolsActivePort");
   if (!fs.existsSync(devToolsPath)) {
     return null;
   }
@@ -14707,8 +14893,8 @@ function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
   const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
   return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
 }
-function normalizeWebSocketPath(path15) {
-  return path15.startsWith("/") ? path15 : `/${path15}`;
+function normalizeWebSocketPath(path18) {
+  return path18.startsWith("/") ? path18 : `/${path18}`;
 }
 function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
   try {
@@ -14754,20 +14940,20 @@ var SESSION_SKIPPED_PROFILE_DIRECTORIES = /* @__PURE__ */ new Set([
   "Network"
 ]);
 async function createBrowserProfileSnapshot(input) {
-  const sourceUserDataDir = path7.resolve(expandHome(input.sourceUserDataDir));
-  const targetUserDataDir = path7.resolve(expandHome(input.targetUserDataDir));
+  const sourceUserDataDir = path10.resolve(expandHome(input.sourceUserDataDir));
+  const targetUserDataDir = path10.resolve(expandHome(input.targetUserDataDir));
   const profileDirectory = input.profileDirectory?.trim();
   const copyMode = input.copyMode;
   await promises.mkdir(targetUserDataDir, { recursive: true });
   await clearChromeSingletonEntries(targetUserDataDir);
   if (profileDirectory) {
-    const sourceProfileDir = path7.join(sourceUserDataDir, profileDirectory);
+    const sourceProfileDir = path10.join(sourceUserDataDir, profileDirectory);
     if (!fs.existsSync(sourceProfileDir)) {
       throw new Error(
         `Chrome profile "${profileDirectory}" was not found in "${sourceUserDataDir}".`
       );
     }
-    await promises.cp(sourceProfileDir, path7.join(targetUserDataDir, profileDirectory), {
+    await promises.cp(sourceProfileDir, path10.join(targetUserDataDir, profileDirectory), {
       recursive: true,
       filter: (candidate) => shouldCopyEntry({
         candidatePath: candidate,
@@ -14791,8 +14977,8 @@ async function copyRootLevelEntries(input) {
     if (CHROME_SINGLETON_ENTRIES.has(entry) || entry === input.selectedProfileDirectory) {
       continue;
     }
-    const sourcePath = path7.join(input.sourceUserDataDir, entry);
-    const targetPath = path7.join(input.targetUserDataDir, entry);
+    const sourcePath = path10.join(input.sourceUserDataDir, entry);
+    const targetPath = path10.join(input.targetUserDataDir, entry);
     const entryStat = await promises.stat(sourcePath).catch(() => null);
     if (!entryStat) {
       continue;
@@ -14824,7 +15010,7 @@ async function copyRootLevelEntries(input) {
   }
 }
 function isProfileDirectory(userDataDir, entry) {
-  return fs.existsSync(path7.join(userDataDir, entry, "Preferences"));
+  return fs.existsSync(path10.join(userDataDir, entry, "Preferences"));
 }
 function shouldCopyEntry(input) {
   const entryName = input.candidatePath.split("/").at(-1)?.split("\\").at(-1) ?? input.candidatePath;
@@ -14834,7 +15020,7 @@ function shouldCopyEntry(input) {
   if (input.copyMode !== "session") {
     return true;
   }
-  const relativePath = path7.relative(input.rootPath, input.candidatePath);
+  const relativePath = path10.relative(input.rootPath, input.candidatePath);
   if (relativePath.length === 0) {
     return true;
   }
@@ -15316,7 +15502,7 @@ function pickStealthProfilePreset(overrides) {
 var OPENSTEER_LIVE_SESSION_LAYOUT = "opensteer-session";
 var OPENSTEER_LIVE_SESSION_VERSION = 1;
 function resolveLiveSessionRecordPath(rootPath, provider) {
-  return path7__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
+  return path10__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
 }
 function resolveLocalSessionRecordPath(rootPath) {
   return resolveLiveSessionRecordPath(rootPath, "local");
@@ -15336,27 +15522,467 @@ async function readPersistedSessionRecord(rootPath, provider) {
   if (provider === "cloud" && isPersistedCloudSessionRecord(parsed)) {
     return parsed;
   }
-  return void 0;
+  return void 0;
+}
+async function readPersistedCloudSessionRecord(rootPath) {
+  const record = await readPersistedSessionRecord(rootPath, "cloud");
+  return record?.provider === "cloud" ? record : void 0;
+}
+async function readPersistedLocalBrowserSessionRecord(rootPath) {
+  const record = await readPersistedSessionRecord(rootPath, "local");
+  return record?.provider === "local" ? record : void 0;
+}
+async function writePersistedSessionRecord(rootPath, record) {
+  await writeJsonFileAtomic(resolveLiveSessionRecordPath(rootPath, record.provider), record);
+}
+async function clearPersistedSessionRecord(rootPath, provider) {
+  await promises.rm(resolveLiveSessionRecordPath(rootPath, provider), { force: true });
+}
+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);
+}
+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;
+}
+function resolveOpensteerStateDir() {
+  const explicit = process.env.OPENSTEER_HOME?.trim();
+  if (explicit) {
+    return path10__default.default.resolve(explicit);
+  }
+  if (process.platform === "win32") {
+    return path10__default.default.join(
+      process.env.LOCALAPPDATA ?? path10__default.default.join(os.homedir(), "AppData", "Local"),
+      "Opensteer"
+    );
+  }
+  if (process.platform === "darwin") {
+    return path10__default.default.join(os.homedir(), "Library", "Application Support", "Opensteer");
+  }
+  return path10__default.default.join(
+    process.env.XDG_STATE_HOME ?? path10__default.default.join(os.homedir(), ".local", "state"),
+    "opensteer"
+  );
+}
+function resolveLocalViewRootDir() {
+  return path10__default.default.join(resolveOpensteerStateDir(), "local-view");
+}
+function resolveLocalViewPreferencesPath() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "preferences.json");
+}
+function resolveLocalViewServiceDir() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "service");
+}
+function resolveLocalViewSessionsDir() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "sessions");
+}
+function resolveLocalViewServiceLockDir() {
+  return path10__default.default.join(resolveLocalViewServiceDir(), "startup.lock");
+}
+function resolveLocalViewServiceStatePath() {
+  return path10__default.default.join(resolveLocalViewServiceDir(), "state.json");
+}
+
+// src/local-view/preferences.ts
+var OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT = "opensteer-local-view-preferences";
+var OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION = 1;
+async function resolveLocalViewMode() {
+  const preferences = await readLocalViewPreferences();
+  return preferences?.mode ?? "auto";
+}
+async function readLocalViewPreferences() {
+  const preferencesPath = resolveLocalViewPreferencesPath();
+  if (!await pathExists(preferencesPath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(preferencesPath);
+  return isPersistedLocalViewPreferences(parsed) ? parsed : void 0;
+}
+function isPersistedLocalViewPreferences(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION && (value.mode === "auto" || value.mode === "manual") && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+}
+var LOCK_OWNER_FILE = "owner.json";
+var LOCK_RECLAIMER_DIR = "reclaimer";
+var LOCK_RETRY_DELAY_MS = 50;
+async function acquireDirLock(lockDirPath) {
+  while (true) {
+    const releaseLock = await tryAcquireDirLock(lockDirPath);
+    if (releaseLock) {
+      return releaseLock;
+    }
+    await sleep(LOCK_RETRY_DELAY_MS);
+  }
+}
+async function tryAcquireDirLock(lockDirPath) {
+  await promises.mkdir(path10.dirname(lockDirPath), { recursive: true });
+  while (true) {
+    const tempLockDirPath = `${lockDirPath}-${String(process.pid)}-${String(CURRENT_PROCESS_OWNER.processStartedAtMs)}-${crypto.randomUUID()}`;
+    try {
+      await promises.mkdir(tempLockDirPath);
+      await writeLockOwner(tempLockDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await promises.rename(tempLockDirPath, lockDirPath);
+        break;
+      } catch (error) {
+        if (!wasDirPublishedByAnotherProcess(error, lockDirPath)) {
+          throw error;
+        }
+      }
+    } finally {
+      await promises.rm(tempLockDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const owner = await readLockOwner(lockDirPath);
+    if ((!owner || await getProcessLiveness(owner) === "dead") && await tryReclaimStaleLock(lockDirPath, owner)) {
+      continue;
+    }
+    return null;
+  }
+  return async () => {
+    await promises.rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  };
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function wasDirPublishedByAnotherProcess(error, targetDirPath) {
+  const code = getErrorCode(error);
+  return fs.existsSync(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+}
+async function writeLockOwner(lockDirPath, owner) {
+  await promises.writeFile(path10.join(lockDirPath, LOCK_OWNER_FILE), JSON.stringify(owner));
+}
+async function readLockOwner(lockDirPath) {
+  return readLockParticipant(path10.join(lockDirPath, LOCK_OWNER_FILE));
+}
+async function readLockParticipant(filePath) {
+  return (await readLockParticipantRecord(filePath)).owner;
+}
+async function readLockParticipantRecord(filePath) {
+  try {
+    const raw = await promises.readFile(filePath, "utf8");
+    return {
+      exists: true,
+      owner: parseProcessOwner(JSON.parse(raw))
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode(error) !== "ENOENT",
+      owner: null
+    };
+  }
+}
+async function readLockReclaimerRecord(lockDirPath) {
+  return readLockParticipantRecord(path10.join(buildLockReclaimerDirPath(lockDirPath), LOCK_OWNER_FILE));
+}
+async function tryReclaimStaleLock(lockDirPath, expectedOwner) {
+  if (!await tryAcquireLockReclaimer(lockDirPath)) {
+    return false;
+  }
+  let reclaimed = false;
+  try {
+    const owner = await readLockOwner(lockDirPath);
+    if (!processOwnersEqual(owner, expectedOwner)) {
+      return false;
+    }
+    if (owner && await getProcessLiveness(owner) !== "dead") {
+      return false;
+    }
+    await promises.rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+    reclaimed = !fs.existsSync(lockDirPath);
+    return reclaimed;
+  } finally {
+    if (!reclaimed) {
+      await promises.rm(buildLockReclaimerDirPath(lockDirPath), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function tryAcquireLockReclaimer(lockDirPath) {
+  const reclaimerDirPath = buildLockReclaimerDirPath(lockDirPath);
+  while (true) {
+    const tempReclaimerDirPath = `${reclaimerDirPath}-${String(process.pid)}-${String(CURRENT_PROCESS_OWNER.processStartedAtMs)}-${crypto.randomUUID()}`;
+    try {
+      await promises.mkdir(tempReclaimerDirPath);
+      await writeLockOwner(tempReclaimerDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await promises.rename(tempReclaimerDirPath, reclaimerDirPath);
+        return true;
+      } catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+          return false;
+        }
+        if (!wasDirPublishedByAnotherProcess(error, reclaimerDirPath)) {
+          throw error;
+        }
+      }
+    } catch (error) {
+      if (getErrorCode(error) === "ENOENT") {
+        return false;
+      }
+      throw error;
+    } finally {
+      await promises.rm(tempReclaimerDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const reclaimerRecord = await readLockReclaimerRecord(lockDirPath);
+    if (!reclaimerRecord.exists || !reclaimerRecord.owner) {
+      return false;
+    }
+    if (await getProcessLiveness(reclaimerRecord.owner) !== "dead") {
+      return false;
+    }
+    await promises.rm(reclaimerDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+function buildLockReclaimerDirPath(lockDirPath) {
+  return path10.join(lockDirPath, LOCK_RECLAIMER_DIR);
+}
+async function sleep(ms) {
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+var OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT = "opensteer-local-view-service";
+var OPENSTEER_LOCAL_VIEW_SERVICE_VERSION = 3;
+async function readLocalViewServiceState() {
+  const statePath = resolveLocalViewServiceStatePath();
+  if (!await pathExists(statePath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(statePath);
+  if (!isPersistedLocalViewServiceState(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+async function isLocalViewServiceStateLive(state) {
+  return await getLocalViewServiceStateLiveness(state) !== "dead";
+}
+async function getLocalViewServiceStateLiveness(state) {
+  if (state === void 0) {
+    return "dead";
+  }
+  return getProcessLiveness({
+    pid: state.pid,
+    processStartedAtMs: state.processStartedAtMs
+  });
+}
+function isPersistedLocalViewServiceState(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_SERVICE_VERSION && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.processStartedAtMs === "number" && Number.isFinite(value.processStartedAtMs) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.port === "number" && Number.isFinite(value.port) && typeof value.token === "string" && value.token.length > 0 && typeof value.url === "string" && value.url.length > 0;
+}
+
+// src/local-view/service.ts
+var LOCAL_VIEW_STARTUP_TIMEOUT_MS = 1e4;
+var LOCAL_VIEW_STARTUP_POLL_MS = 100;
+async function ensureLocalViewServiceRunning() {
+  const current = await readReachableLocalViewServiceState();
+  if (current !== void 0) {
+    return current;
+  }
+  const releaseLock = await acquireDirLock(resolveLocalViewServiceLockDir());
+  try {
+    const lockedState = await readReachableLocalViewServiceState();
+    if (lockedState !== void 0) {
+      return lockedState;
+    }
+    await spawnLocalViewService();
+    const started = await waitForLocalViewService();
+    if (!started) {
+      throw new Error("Timed out while starting the local view service.");
+    }
+    return started;
+  } finally {
+    await releaseLock();
+  }
+}
+function spawnLocalViewService() {
+  const command = resolveLocalViewSpawnCommand();
+  const child = child_process.spawn(command.executable, command.args, {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      ...command.env ?? {},
+      OPENSTEER_LOCAL_VIEW_BOOT_TOKEN: process.env.OPENSTEER_LOCAL_VIEW_BOOT_TOKEN ?? crypto.randomBytes(24).toString("hex")
+    },
+    detached: process.platform !== "win32",
+    stdio: "ignore"
+  });
+  child.unref();
+}
+async function waitForLocalViewService() {
+  const deadline = Date.now() + LOCAL_VIEW_STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const state = await readReachableLocalViewServiceState();
+    if (state !== void 0) {
+      return state;
+    }
+    await delay(LOCAL_VIEW_STARTUP_POLL_MS);
+  }
+  return void 0;
+}
+async function readReachableLocalViewServiceState() {
+  const state = await readLocalViewServiceState();
+  if (state === void 0 || !await isLocalViewServiceStateLive(state)) {
+    return void 0;
+  }
+  return await isLocalViewServiceReachable(state.url, state.token) ? state : void 0;
+}
+async function isLocalViewServiceReachable(baseUrl, token) {
+  try {
+    const response = await fetch(new URL("/api/health", baseUrl), {
+      headers: {
+        "x-opensteer-local-token": token
+      }
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function resolveLocalViewSpawnCommand() {
+  const moduleDir = path10__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+  const distServicePath = findExistingPath([
+    path10__default.default.join(moduleDir, "local-view", "serve-entry.js"),
+    path10__default.default.join(moduleDir, "serve-entry.js"),
+    path10__default.default.join(moduleDir, "..", "local-view", "serve-entry.js")
+  ]);
+  if (distServicePath) {
+    return {
+      executable: process.execPath,
+      args: [distServicePath]
+    };
+  }
+  const distCliPath = findExistingPath([
+    path10__default.default.join(moduleDir, "cli", "bin.js"),
+    path10__default.default.join(moduleDir, "..", "cli", "bin.js")
+  ]);
+  if (distCliPath) {
+    return {
+      executable: process.execPath,
+      args: [distCliPath, "view", "serve"]
+    };
+  }
+  const srcServicePath = findExistingPath([
+    path10__default.default.join(moduleDir, "serve-entry.ts"),
+    path10__default.default.join(moduleDir, "..", "local-view", "serve-entry.ts"),
+    path10__default.default.join(moduleDir, "..", "src", "local-view", "serve-entry.ts")
+  ]);
+  if (srcServicePath) {
+    const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    const tsxLoaderPath = require2.resolve("tsx");
+    const tsconfigPath = findNearestTsconfig(path10__default.default.resolve(moduleDir, "..", "..", ".."));
+    return {
+      executable: process.execPath,
+      args: ["--import", tsxLoaderPath, srcServicePath],
+      ...tsconfigPath ? { env: { TSX_TSCONFIG_PATH: tsconfigPath } } : {}
+    };
+  }
+  const srcCliPath = findExistingPath([
+    path10__default.default.join(moduleDir, "..", "cli", "bin.ts"),
+    path10__default.default.join(moduleDir, "..", "src", "cli", "bin.ts")
+  ]);
+  if (srcCliPath) {
+    const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    const tsxLoaderPath = require2.resolve("tsx");
+    const tsconfigPath = findNearestTsconfig(path10__default.default.resolve(moduleDir, "..", "..", ".."));
+    return {
+      executable: process.execPath,
+      args: ["--import", tsxLoaderPath, srcCliPath, "view", "serve"],
+      ...tsconfigPath ? { env: { TSX_TSCONFIG_PATH: tsconfigPath } } : {}
+    };
+  }
+  throw new Error(`Could not resolve the Opensteer CLI entrypoint from ${moduleDir}.`);
+}
+function findExistingPath(candidates) {
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+function findNearestTsconfig(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const candidate = path10__default.default.join(currentDir, "tsconfig.json");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parentDir = path10__default.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
 }
-async function readPersistedCloudSessionRecord(rootPath) {
-  const record = await readPersistedSessionRecord(rootPath, "cloud");
-  return record?.provider === "cloud" ? record : void 0;
+function delay(ms) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
+  });
 }
-async function readPersistedLocalBrowserSessionRecord(rootPath) {
-  const record = await readPersistedSessionRecord(rootPath, "local");
-  return record?.provider === "local" ? record : void 0;
+var OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT = "opensteer-local-view-session";
+var OPENSTEER_LOCAL_VIEW_SESSION_VERSION = 1;
+function buildLocalViewSessionId(input) {
+  const hash = crypto.createHash("sha256").update(`${input.rootPath}
+${String(input.pid)}
+${String(input.startedAt)}`).digest("hex");
+  return `local_${hash.slice(0, 24)}`;
 }
-async function writePersistedSessionRecord(rootPath, record) {
-  await writeJsonFileAtomic(resolveLiveSessionRecordPath(rootPath, record.provider), record);
+function createLocalViewSessionManifest(input) {
+  return {
+    layout: OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT,
+    version: OPENSTEER_LOCAL_VIEW_SESSION_VERSION,
+    sessionId: buildLocalViewSessionId({
+      rootPath: input.rootPath,
+      pid: input.live.pid,
+      startedAt: input.live.startedAt
+    }),
+    rootPath: input.rootPath,
+    ...input.workspace === void 0 ? {} : { workspace: input.workspace },
+    engine: input.live.engine,
+    ownership: input.ownership,
+    pid: input.live.pid,
+    startedAt: input.live.startedAt,
+    updatedAt: Date.now()
+  };
 }
-async function clearPersistedSessionRecord(rootPath, provider) {
-  await promises.rm(resolveLiveSessionRecordPath(rootPath, provider), { force: true });
+async function writeLocalViewSessionManifest(manifest) {
+  await ensureDirectory(resolveLocalViewSessionsDir());
+  await writeJsonFileAtomic(resolveLocalViewSessionManifestPath(manifest.sessionId), manifest);
 }
-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);
+async function deleteLocalViewSessionManifest(sessionId) {
+  await promises.rm(resolveLocalViewSessionManifestPath(sessionId), { force: true }).catch(() => void 0);
 }
-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;
+function resolveLocalViewSessionManifestPath(sessionId) {
+  return path10__default.default.join(resolveLocalViewSessionsDir(), `${sessionId}.json`);
+}
+
+// src/local-view/registration.ts
+async function bestEffortRegisterLocalViewSession(input) {
+  try {
+    const manifest = createLocalViewSessionManifest(input);
+    await writeLocalViewSessionManifest(manifest);
+    if (await resolveLocalViewMode() === "auto") {
+      void ensureLocalViewServiceRunning().catch(() => void 0);
+    }
+    return manifest;
+  } catch {
+    return void 0;
+  }
+}
+async function bestEffortUnregisterLocalViewSession(sessionId) {
+  if (!sessionId) {
+    return;
+  }
+  await deleteLocalViewSessionManifest(sessionId).catch(() => void 0);
 }
 
 // ../runtime-core/src/internal/engine-selection.ts
@@ -15476,8 +16102,8 @@ var OpensteerBrowserManager = class {
       ...options.browser === void 0 ? {} : { browser: options.browser },
       ...this.contextOptions === void 0 ? {} : { context: this.contextOptions }
     });
-    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7__default.default.join(os.tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
-      rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path10__default.default.join(os.tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
+      rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
       workspace: this.workspace
     }));
     this.cleanupRootOnDisconnect = this.workspace === void 0;
@@ -15538,7 +16164,7 @@ var OpensteerBrowserManager = class {
         userDataDir: "browser/user-data",
         bootstrap: {
           kind: "cloneLocalProfile",
-          sourceUserDataDir: path7__default.default.resolve(input.sourceUserDataDir),
+          sourceUserDataDir: path10__default.default.resolve(input.sourceUserDataDir),
           ...input.sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory: input.sourceProfileDirectory }
         }
       };
@@ -15611,6 +16237,12 @@ var OpensteerBrowserManager = class {
             `workspace "${this.workspace}" already has a live ${live.engine} browser. Close it before reopening with engine "abp".`
           );
         }
+        await bestEffortRegisterLocalViewSession({
+          rootPath: workspace.rootPath,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+          live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+          ownership: "owned"
+        });
         return this.createAdoptedAbpEngine(live);
       }
       await this.ensurePersistentBrowserManifest(workspace);
@@ -15643,9 +16275,17 @@ var OpensteerBrowserManager = class {
         ...launch?.browserExecutablePath === void 0 ? {} : { executablePath: launch.browserExecutablePath }
       };
       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: "owned"
+      });
       try {
         return await this.createAdoptedAbpEngine(liveRecord);
       } catch (error) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
         await terminateProcess(launched.process.pid ?? 0).catch(() => void 0);
         await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
         throw error;
@@ -15665,23 +16305,45 @@ var OpensteerBrowserManager = class {
     });
   }
   async createTemporaryEngine() {
-    const userDataDir = await promises.mkdtemp(path7__default.default.join(os.tmpdir(), "opensteer-temporary-browser-"));
+    const userDataDir = await promises.mkdtemp(path10__default.default.join(os.tmpdir(), "opensteer-temporary-browser-"));
     await clearChromeSingletonEntries(userDataDir);
     const launched = await launchOwnedBrowser({
       userDataDir,
       ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
       ...this.contextOptions?.viewport === void 0 ? {} : { viewport: this.contextOptions.viewport }
     });
+    const temporaryLiveRecord = {
+      layout: "opensteer-session",
+      version: 1,
+      provider: "local",
+      engine: "playwright",
+      endpoint: launched.endpoint,
+      pid: launched.pid,
+      startedAt: Date.now(),
+      updatedAt: Date.now(),
+      executablePath: launched.executablePath,
+      userDataDir
+    };
+    await writePersistedSessionRecord(this.rootPath, temporaryLiveRecord);
+    const localViewManifest = await bestEffortRegisterLocalViewSession({
+      rootPath: this.rootPath,
+      live: temporaryLiveRecord,
+      ownership: "owned"
+    });
     try {
       return await this.createAttachedEngine({
         endpoint: launched.endpoint,
         freshTab: false,
         onDispose: async () => {
+          await bestEffortUnregisterLocalViewSession(localViewManifest?.sessionId);
+          await clearPersistedSessionRecord(this.rootPath, "local").catch(() => void 0);
           await terminateProcess(launched.pid).catch(() => void 0);
           await promises.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
         }
       });
     } catch (error) {
+      await bestEffortUnregisterLocalViewSession(localViewManifest?.sessionId);
+      await clearPersistedSessionRecord(this.rootPath, "local").catch(() => void 0);
       await terminateProcess(launched.pid).catch(() => void 0);
       await promises.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
       throw error;
@@ -15709,6 +16371,12 @@ var OpensteerBrowserManager = class {
         if (live.endpoint === void 0) {
           throw new Error("workspace live browser record is missing a DevTools endpoint.");
         }
+        await bestEffortRegisterLocalViewSession({
+          rootPath: workspace.rootPath,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+          live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+          ownership: "owned"
+        });
         return this.createAttachedEngine({
           endpoint: live.endpoint,
           freshTab: false,
@@ -15731,6 +16399,13 @@ var OpensteerBrowserManager = class {
         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: "owned"
+      });
       try {
         return await this.createAttachedEngine({
           endpoint: launched.endpoint,
@@ -15738,6 +16413,7 @@ var OpensteerBrowserManager = class {
           onDispose: async () => void 0
         });
       } catch (error) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
         await terminateProcess(launched.pid).catch(() => void 0);
         await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
         throw error;
@@ -15888,6 +16564,10 @@ var OpensteerBrowserManager = class {
       await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
       return;
     }
+    await this.unregisterLocalViewSessionForRecord(
+      workspace.rootPath,
+      toPersistedLocalBrowserSessionRecord(this.workspace, live)
+    );
     if (live.engine === "playwright") {
       if (live.endpoint !== void 0) {
         await requestBrowserClose(live.endpoint).catch(() => void 0);
@@ -15914,6 +16594,15 @@ var OpensteerBrowserManager = class {
       throw new Error(`browser.${method}() requires a persistent workspace browser.`);
     }
   }
+  async unregisterLocalViewSessionForRecord(rootPath, record) {
+    await bestEffortUnregisterLocalViewSession(
+      buildLocalViewSessionId({
+        rootPath,
+        pid: record.pid,
+        startedAt: record.startedAt
+      })
+    );
+  }
 };
 function normalizeWorkspace(workspace) {
   const normalized = workspace?.trim();
@@ -15977,8 +16666,14 @@ async function launchOwnedBrowser(input) {
   await ensureDirectory(input.userDataDir);
   await clearChromeSingletonEntries(input.userDataDir);
   await sanitizeChromeProfile(input.userDataDir);
+  const requestedRemoteDebuggingPort = readRequestedRemoteDebuggingPort(input.launch?.args);
   const executablePath = resolveChromeExecutablePath(input.launch?.executablePath);
-  const args = buildChromeArgs(input.userDataDir, input.launch, input.viewport);
+  const args = buildChromeArgs(
+    input.userDataDir,
+    input.launch,
+    input.viewport,
+    requestedRemoteDebuggingPort
+  );
   const child = child_process.spawn(executablePath, args, {
     stdio: ["ignore", "ignore", "pipe"],
     detached: process.platform !== "win32"
@@ -15994,7 +16689,8 @@ async function launchOwnedBrowser(input) {
     userDataDir: input.userDataDir,
     timeoutMs: input.launch?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     childExited: async () => child.exitCode,
-    stderrLines
+    stderrLines,
+    ...requestedRemoteDebuggingPort !== void 0 && requestedRemoteDebuggingPort > 0 ? { requestedRemoteDebuggingPort } : {}
   }).catch(async (error) => {
     child.kill("SIGKILL");
     throw error;
@@ -16005,10 +16701,10 @@ async function launchOwnedBrowser(input) {
     executablePath
   };
 }
-function buildChromeArgs(userDataDir, launch, viewport) {
+function buildChromeArgs(userDataDir, launch, viewport, requestedRemoteDebuggingPort) {
   const isHeadless = launch?.headless ?? true;
   const args = [
-    "--remote-debugging-port=0",
+    ...requestedRemoteDebuggingPort === void 0 ? ["--remote-debugging-port=0"] : [],
     "--no-first-run",
     "--no-default-browser-check",
     "--disable-blink-features=AutomationControlled",
@@ -16059,14 +16755,69 @@ async function waitForDevToolsEndpoint(input) {
         return `ws://127.0.0.1:${String(activePort.port)}${activePort.webSocketPath}`;
       }
     }
+    if (input.requestedRemoteDebuggingPort !== void 0) {
+      const endpoint = await tryInspectRemoteDebuggingPort(
+        input.requestedRemoteDebuggingPort,
+        input.timeoutMs
+      );
+      if (endpoint !== void 0) {
+        return endpoint;
+      }
+    }
     const exitCode = await input.childExited();
     if (exitCode !== null) {
       throw new Error(formatChromeLaunchError(input.stderrLines));
     }
-    await sleep(DEVTOOLS_POLL_INTERVAL_MS);
+    await sleep2(DEVTOOLS_POLL_INTERVAL_MS);
   }
   throw new Error(formatChromeLaunchError(input.stderrLines));
 }
+function readRequestedRemoteDebuggingPort(args) {
+  if (args === void 0 || args.length === 0) {
+    return void 0;
+  }
+  let explicitFlagFound = false;
+  let port;
+  for (let index = 0; index < args.length; index += 1) {
+    const entry = args[index];
+    if (entry === "--remote-debugging-port") {
+      explicitFlagFound = true;
+      const next = args[index + 1];
+      if (next !== void 0) {
+        port = parseRemoteDebuggingPort(next);
+        index += 1;
+      }
+      continue;
+    }
+    if (entry.startsWith("--remote-debugging-port=")) {
+      explicitFlagFound = true;
+      port = parseRemoteDebuggingPort(entry.slice("--remote-debugging-port=".length));
+    }
+  }
+  return explicitFlagFound ? port : void 0;
+}
+function parseRemoteDebuggingPort(value) {
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    return void 0;
+  }
+  return parsed;
+}
+async function tryInspectRemoteDebuggingPort(port, timeoutMs) {
+  try {
+    const inspected = await inspectCdpEndpoint({
+      endpoint: `http://127.0.0.1:${String(port)}`,
+      timeoutMs: Math.min(2e3, timeoutMs)
+    });
+    return inspected.endpoint;
+  } catch {
+    return void 0;
+  }
+}
 function formatChromeLaunchError(stderrLines) {
   const collapsed = stderrLines.join("").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
   if (collapsed.length === 0) {
@@ -16165,12 +16916,12 @@ async function waitForProcessExit(pid, timeoutMs) {
     if (!isProcessRunning(pid)) {
       return true;
     }
-    await sleep(50);
+    await sleep2(50);
   }
   return !isProcessRunning(pid);
 }
 function resolveAbpSessionDir(workspace) {
-  return path7__default.default.join(workspace.livePath, "abp-session");
+  return path10__default.default.join(workspace.livePath, "abp-session");
 }
 async function allocateEphemeralPort() {
   const { allocatePort } = await loadAbpModule();
@@ -16227,14 +16978,14 @@ function resolveStealthProfile(input) {
 function isStealthProfile(input) {
   return input.id !== void 0 && input.platform !== void 0 && input.browserBrand !== void 0 && input.browserVersion !== void 0 && input.userAgent !== void 0 && input.viewport !== void 0 && input.screenResolution !== void 0 && input.devicePixelRatio !== void 0 && input.maxTouchPoints !== void 0 && input.webglVendor !== void 0 && input.webglRenderer !== void 0 && input.fonts !== void 0 && input.canvasNoiseSeed !== void 0 && input.audioNoiseSeed !== void 0 && input.locale !== void 0 && input.timezoneId !== void 0;
 }
-async function sleep(ms) {
+async function sleep2(ms) {
   await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var ENV_FILENAMES = [".env", ".env.local"];
 var OPENSTEER_ENV_PREFIX = "OPENSTEER_";
 var opensteerEnvironmentCache = /* @__PURE__ */ new Map();
 function resolveOpensteerEnvironment(cwd = process.cwd(), baseEnv = process.env) {
-  const resolvedCwd = path7__default.default.resolve(cwd);
+  const resolvedCwd = path10__default.default.resolve(cwd);
   const signature = buildEnvironmentSignature(baseEnv, isOpensteerEnvironmentKey);
   const cached = opensteerEnvironmentCache.get(resolvedCwd);
   if (cached && cached.signature === signature) {
@@ -16249,10 +17000,10 @@ function resolveOpensteerEnvironment(cwd = process.cwd(), baseEnv = process.env)
 }
 function collectDirectories(cwd) {
   const directories = [];
-  let current = path7__default.default.resolve(cwd);
+  let current = path10__default.default.resolve(cwd);
   for (; ; ) {
     directories.unshift(current);
-    const parent = path7__default.default.dirname(current);
+    const parent = path10__default.default.dirname(current);
     if (parent === current) {
       return directories;
     }
@@ -16295,7 +17046,7 @@ function resolveEnvironmentFiles(cwd, baseEnv, predicate) {
   const directories = collectDirectories(cwd);
   for (const directory of directories) {
     for (const filename of ENV_FILENAMES) {
-      const filePath = path7__default.default.join(directory, filename);
+      const filePath = path10__default.default.join(directory, filename);
       if (!fs.existsSync(filePath)) {
         continue;
       }
@@ -16374,17 +17125,17 @@ async function readBrowserCookies(input = {}) {
   const brand2 = resolveRequestedBrand(input);
   const userDataDir = resolveBrandUserDataDir(brand2, input.userDataDir);
   const profileDirectory = input.profileDirectory ?? "Default";
-  const cookiesPath = path7.join(userDataDir, profileDirectory, "Cookies");
+  const cookiesPath = path10.join(userDataDir, profileDirectory, "Cookies");
   if (!fs.existsSync(cookiesPath)) {
     throw new Error(
       `Cookies database not found at "${cookiesPath}". Verify the browser brand, user-data-dir, and profile-directory are correct.`
     );
   }
-  const tempDir = await promises.mkdtemp(path7.join(os.tmpdir(), "opensteer-cookies-"));
+  const tempDir = await promises.mkdtemp(path10.join(os.tmpdir(), "opensteer-cookies-"));
   try {
     await copyCookiesDatabase(cookiesPath, tempDir);
     const decryptionKey = await resolveDecryptionKey(brand2.id, userDataDir);
-    const rows = queryAllCookies(path7.join(tempDir, "Cookies"));
+    const rows = queryAllCookies(path10.join(tempDir, "Cookies"));
     const cookies = decryptCookieRows(rows, decryptionKey);
     return {
       cookies,
@@ -16410,11 +17161,11 @@ function resolveRequestedBrand(input) {
   return installed.brand;
 }
 async function copyCookiesDatabase(cookiesPath, destDir) {
-  await promises.copyFile(cookiesPath, path7.join(destDir, "Cookies"));
+  await promises.copyFile(cookiesPath, path10.join(destDir, "Cookies"));
   for (const suffix of ["-wal", "-journal", "-shm"]) {
     const src = cookiesPath + suffix;
     if (fs.existsSync(src)) {
-      await promises.copyFile(src, path7.join(destDir, "Cookies" + suffix)).catch(() => void 0);
+      await promises.copyFile(src, path10.join(destDir, "Cookies" + suffix)).catch(() => void 0);
     }
   }
 }
@@ -16491,7 +17242,7 @@ async function resolveKeychainPassword(brandId) {
   }
 }
 async function resolveWindowsMasterKey(userDataDir) {
-  const localStatePath = path7.join(userDataDir, "Local State");
+  const localStatePath = path10.join(userDataDir, "Local State");
   let localState;
   try {
     localState = JSON.parse(await promises.readFile(localStatePath, "utf8"));
@@ -16692,14 +17443,14 @@ function toPortableBrowserProfileCookieRecord(cookie) {
   if (!name || !domain) {
     return null;
   }
-  const path15 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
+  const path18 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
   const expiresAt = typeof cookie.expires === "number" && Number.isFinite(cookie.expires) && cookie.expires > 0 ? Math.floor(cookie.expires * 1e3) : null;
   const sameSite = normalizeSameSite(cookie.sameSite);
   return {
     name,
     value: cookie.value,
     domain,
-    path: path15,
+    path: path18,
     secure: cookie.secure,
     httpOnly: cookie.httpOnly,
     ...sameSite === void 0 ? {} : { sameSite },
@@ -16768,7 +17519,7 @@ async function waitForBrowserProfileImport(client, importId) {
     if (current.status === "failed") {
       throw new Error(current.error ?? "Browser profile sync failed.");
     }
-    await sleep2(DEFAULT_POLL_INTERVAL_MS);
+    await sleep3(DEFAULT_POLL_INTERVAL_MS);
   }
   throw new Error(`Timed out waiting for browser profile sync "${importId}" to finish.`);
 }
@@ -16777,7 +17528,7 @@ function normalizePlatform(platform) {
   if (platform === "win32") return "windows";
   return platform;
 }
-async function sleep2(ms) {
+async function sleep3(ms) {
   await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
@@ -16791,21 +17542,24 @@ var OpensteerCloudClient = class {
   getConfig() {
     return this.config;
   }
-  async createSession(input = {}) {
-    const response = await this.request("/v1/sessions", {
-      method: "POST",
-      body: {
-        ...input.name === void 0 ? {} : { name: input.name },
-        ...input.browser === void 0 ? {} : { browser: input.browser },
-        ...input.context === void 0 ? {} : { context: input.context },
-        ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile },
-        ...input.observability === void 0 ? {} : { observability: input.observability },
-        ...input.sourceType === void 0 ? {} : { sourceType: input.sourceType },
-        ...input.sourceRef === void 0 ? {} : { sourceRef: input.sourceRef },
-        ...input.localWorkspaceRootPath === void 0 ? {} : { localWorkspaceRootPath: input.localWorkspaceRootPath },
-        ...input.locality === void 0 ? {} : { locality: input.locality }
-      }
-    });
+  async createSession(input = {}, options = {}) {
+    const response = await this.request(
+      "/v1/sessions",
+      {
+        method: "POST",
+        body: {
+          ...input.name === void 0 ? {} : { name: input.name },
+          ...input.browser === void 0 ? {} : { browser: input.browser },
+          ...input.context === void 0 ? {} : { context: input.context },
+          ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile },
+          ...input.observability === void 0 ? {} : { observability: input.observability },
+          ...input.sourceType === void 0 ? {} : { sourceType: input.sourceType },
+          ...input.sourceRef === void 0 ? {} : { sourceRef: input.sourceRef },
+          ...input.localWorkspaceRootPath === void 0 ? {} : { localWorkspaceRootPath: input.localWorkspaceRootPath }
+        }
+      },
+      options
+    );
     return await response.json();
   }
   async listSessions() {
@@ -16814,19 +17568,27 @@ var OpensteerCloudClient = class {
     });
     return response.json();
   }
-  async getSession(sessionId) {
-    const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}`, {
-      method: "GET"
-    });
+  async getSession(sessionId, options = {}) {
+    const response = await this.request(
+      `/v1/sessions/${encodeURIComponent(sessionId)}`,
+      {
+        method: "GET"
+      },
+      options
+    );
     return await response.json();
   }
-  async issueAccess(sessionId, capabilities) {
-    const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}/access`, {
-      method: "POST",
-      body: {
-        capabilities
-      }
-    });
+  async issueAccess(sessionId, capabilities, options = {}) {
+    const response = await this.request(
+      `/v1/sessions/${encodeURIComponent(sessionId)}/access`,
+      {
+        method: "POST",
+        body: {
+          capabilities
+        }
+      },
+      options
+    );
     return await response.json();
   }
   async getSessionRecording(sessionId) {
@@ -16908,28 +17670,17 @@ var OpensteerCloudClient = class {
   async syncBrowserProfileCookies(input) {
     return syncBrowserProfileCookies(this, input);
   }
-  async importSelectorCache(entries) {
-    const response = await this.request("/selector-cache/import", {
+  async importDescriptors(entries) {
+    const response = await this.request("/registry/descriptors/import", {
       method: "POST",
-      body: {
-        entries: entries.map((entry) => ({
-          workspace: entry.workspace,
-          method: entry.method,
-          persistHash: entry.persistHash,
-          ...entry.persist === void 0 ? {} : { persist: entry.persist },
-          path: entry.path,
-          ...entry.schemaHash === void 0 ? {} : { schemaHash: entry.schemaHash },
-          createdAt: entry.createdAt,
-          updatedAt: entry.updatedAt
-        }))
-      }
+      body: { entries }
     });
     return await response.json();
   }
-  async importDescriptors(entries) {
-    const response = await this.request("/registry/descriptors/import", {
+  async importRequestPlans(input) {
+    const response = await this.request("/registry/request-plans/import", {
       method: "POST",
-      body: { entries }
+      body: input
     });
     return await response.json();
   }
@@ -16942,7 +17693,7 @@ var OpensteerCloudClient = class {
       "content-type": "application/json; charset=utf-8"
     };
   }
-  async request(pathname, init) {
+  async request(pathname, init, options = {}) {
     const url = `${this.config.baseUrl}${pathname}`;
     let response;
     try {
@@ -16950,7 +17701,7 @@ var OpensteerCloudClient = class {
         method: init.method,
         headers: this.buildHeaders(),
         ...init.body === void 0 ? {} : { body: JSON.stringify(init.body) },
-        signal: AbortSignal.timeout(3e4)
+        signal: createRequestSignal(options)
       });
     } catch (error) {
       throw wrapCloudFetchError(error, {
@@ -16975,12 +17726,19 @@ var OpensteerCloudClient = class {
           `Unexpected cloud session status "${String(session.status)}" while waiting for close.`
         );
       }
-      await delay(CLOUD_CLOSE_POLL_INTERVAL_MS);
+      await delay2(CLOUD_CLOSE_POLL_INTERVAL_MS);
     }
     throw new Error(`Timed out waiting for cloud session ${sessionId} to close.`);
   }
 };
-function delay(ms) {
+function createRequestSignal(options) {
+  const timeoutSignal = AbortSignal.timeout(options.timeoutMs ?? 3e4);
+  if (options.signal === void 0) {
+    return timeoutSignal;
+  }
+  return AbortSignal.any([options.signal, timeoutSignal]);
+}
+function delay2(ms) {
   return new Promise((resolve4) => {
     setTimeout(resolve4, ms);
   });
@@ -17030,7 +17788,7 @@ function resolveCloudConfig(input = {}) {
 
 // ../runtime-core/package.json
 var package_default = {
-  version: "0.1.7"};
+  version: "0.2.1"};
 
 // ../runtime-core/src/version.ts
 var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
@@ -17786,11 +18544,11 @@ var NetworkHistory = class {
 var MATCHED_TLS_BINARY_NAMES = ["curl-impersonate-chrome", "curl_chrome"];
 async function executeMatchedTlsTransportRequest(input) {
   const binary = await resolveMatchedTlsBinary();
-  const workingDirectory = await promises.mkdtemp(path7__default.default.join(os.tmpdir(), "opensteer-matched-tls-"));
-  const headersPath = path7__default.default.join(workingDirectory, "headers.txt");
-  const bodyPath = path7__default.default.join(workingDirectory, "body.bin");
-  const cookiesPath = path7__default.default.join(workingDirectory, "cookies.txt");
-  const requestBodyPath = path7__default.default.join(workingDirectory, "request-body.bin");
+  const workingDirectory = await promises.mkdtemp(path10__default.default.join(os.tmpdir(), "opensteer-matched-tls-"));
+  const headersPath = path10__default.default.join(workingDirectory, "headers.txt");
+  const bodyPath = path10__default.default.join(workingDirectory, "body.bin");
+  const cookiesPath = path10__default.default.join(workingDirectory, "cookies.txt");
+  const requestBodyPath = path10__default.default.join(workingDirectory, "request-body.bin");
   try {
     await promises.writeFile(cookiesPath, toNetscapeCookieJar(input.cookies ?? []), "utf8");
     if (input.request.body !== void 0) {
@@ -17847,10 +18605,10 @@ async function executeMatchedTlsTransportRequest(input) {
   }
 }
 async function resolveMatchedTlsBinary() {
-  const pathEntries = (process.env.PATH ?? "").split(path7__default.default.delimiter).filter((entry) => entry.length > 0);
+  const pathEntries = (process.env.PATH ?? "").split(path10__default.default.delimiter).filter((entry) => entry.length > 0);
   for (const directory of pathEntries) {
     for (const name of MATCHED_TLS_BINARY_NAMES) {
-      const candidate = path7__default.default.join(directory, name);
+      const candidate = path10__default.default.join(directory, name);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -17858,7 +18616,7 @@ async function resolveMatchedTlsBinary() {
     const files = await readDirSafe(directory);
     const discovered = files.find((file) => file.startsWith("curl_chrome"));
     if (discovered !== void 0) {
-      const candidate = path7__default.default.join(directory, discovered);
+      const candidate = path10__default.default.join(directory, discovered);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -20312,11 +21070,11 @@ var SandboxClock = class {
   performanceNow() {
     return this.mode === "manual" ? this.manualNow - this.startedAt : (globalThis.performance?.now() ?? 0) - this.performanceStartedAt;
   }
-  setTimeout(callback, delay3 = 0, ...args) {
-    return this.registerTimer(false, callback, delay3, args);
+  setTimeout(callback, delay4 = 0, ...args) {
+    return this.registerTimer(false, callback, delay4, args);
   }
-  setInterval(callback, delay3 = 0, ...args) {
-    return this.registerTimer(true, callback, delay3, args);
+  setInterval(callback, delay4 = 0, ...args) {
+    return this.registerTimer(true, callback, delay4, args);
   }
   clearTimeout(timerId) {
     this.clearTimer(timerId);
@@ -20337,9 +21095,9 @@ var SandboxClock = class {
       this.clearTimer(timerId);
     }
   }
-  registerTimer(repeat, callback, delay3, args) {
+  registerTimer(repeat, callback, delay4, args) {
     const timerId = this.nextTimerId++;
-    const normalizedDelay = Math.max(0, delay3);
+    const normalizedDelay = Math.max(0, delay4);
     const record = {
       callback,
       args,
@@ -20503,7 +21261,7 @@ async function pollTask(apiKey, taskId, signal) {
   const deadline = Date.now() + 12e4;
   while (Date.now() < deadline) {
     signal?.throwIfAborted?.();
-    await sleep3(3e3, signal);
+    await sleep4(3e3, signal);
     const response = await fetch(CAPSOLVER_GET_TASK_RESULT_URL, {
       method: "POST",
       headers: {
@@ -20547,7 +21305,7 @@ function extractCaptchaToken(solution) {
 function readString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function sleep3(ms, signal) {
+function sleep4(ms, signal) {
   return new Promise((resolve4, reject) => {
     const timeout = setTimeout(resolve4, ms);
     const abort = () => {
@@ -20601,7 +21359,7 @@ async function pollTask2(apiKey, taskId, signal) {
   const deadline = Date.now() + 12e4;
   while (Date.now() < deadline) {
     signal?.throwIfAborted?.();
-    await sleep4(5e3, signal);
+    await sleep5(5e3, signal);
     const response = await fetch(TWO_CAPTCHA_GET_TASK_RESULT_URL, {
       method: "POST",
       headers: {
@@ -20645,7 +21403,7 @@ function extractCaptchaToken2(solution) {
 function readString2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function sleep4(ms, signal) {
+function sleep5(ms, signal) {
   return new Promise((resolve4, reject) => {
     const timeout = setTimeout(resolve4, ms);
     const abort = () => {
@@ -20848,6 +21606,9 @@ var MUTATION_CAPTURE_FINALIZE_TIMEOUT_MS = 5e3;
 var PERSISTED_NETWORK_FLUSH_TIMEOUT_MS = 5e3;
 var PENDING_OPERATION_EVENT_CAPTURE_LIMIT = 64;
 var PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS = 1e3;
+var REPLAY_PROBE_MIN_ATTEMPT_TIMEOUT_MS = 3e3;
+var REPLAY_PROBE_MAX_ATTEMPT_TIMEOUT_MS = 15e3;
+var REPLAY_PROBE_POST_SUCCESS_ATTEMPT_TIMEOUT_MS = 5e3;
 var OpensteerSessionRuntime = class {
   workspace;
   rootPath;
@@ -20879,7 +21640,7 @@ var OpensteerSessionRuntime = class {
     this.workspace = normalizeNamespace2(options.name);
     this.workspaceName = options.workspaceName?.trim() === void 0 || options.workspaceName?.trim().length === 0 ? void 0 : options.workspaceName.trim();
     this.root = options.workspace;
-    this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path7__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
+    this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path10__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
     this.injectedEngine = options.engine;
     this.engineFactory = options.engineFactory;
     this.policy = options.policy ?? defaultPolicy();
@@ -21709,26 +22470,27 @@ var OpensteerSessionRuntime = class {
     }
   }
   async queryNetwork(input = {}, options = {}) {
-    assertValidSemanticOperationInput("network.query", input);
+    const normalizedInput = normalizeNetworkQueryInput(input);
+    assertValidSemanticOperationInput("network.query", normalizedInput);
     const root = await this.ensureRoot();
     const startedAt = Date.now();
     try {
       const output = await this.runWithOperationTimeout(
         "network.query",
         async (timeout) => {
-          await this.syncPersistedNetworkSelection(timeout, input, {
+          await this.syncPersistedNetworkSelection(timeout, normalizedInput, {
             includeBodies: false
           });
           const rawRecords = await timeout.runStep(
             () => root.registry.savedNetwork.query({
-              ...this.toSavedNetworkQueryInput(input),
-              limit: Math.max(input.limit ?? 50, 1e3)
+              ...this.toSavedNetworkQueryInput(normalizedInput),
+              limit: Math.max(normalizedInput.limit ?? 50, 1e3)
             })
           );
-          const filtered = filterNetworkSummaryRecords(rawRecords, input);
+          const filtered = filterNetworkSummaryRecords(rawRecords, normalizedInput);
           const sorted = sortPersistedNetworkRecordsChronologically(filtered);
-          const sliced = sliceNetworkSummaryWindow(sorted, input);
-          const limited = sliced.slice(0, Math.max(1, Math.min(input.limit ?? 50, 200)));
+          const sliced = sliceNetworkSummaryWindow(sorted, normalizedInput);
+          const limited = sliced.slice(0, Math.max(1, Math.min(normalizedInput.limit ?? 50, 200)));
           const summaries = await this.buildNetworkSummaryRecords(limited, timeout);
           return {
             records: summaries
@@ -21742,9 +22504,9 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "ok",
         data: {
-          limit: input.limit ?? 50,
-          ...input.capture === void 0 ? {} : { capture: input.capture },
-          ...input.json === true ? { json: true } : {},
+          limit: normalizedInput.limit ?? 50,
+          ...normalizedInput.capture === void 0 ? {} : { capture: normalizedInput.capture },
+          ...normalizedInput.json === true ? { json: true } : {},
           count: output.records.length
         },
         context: buildRuntimeTraceContext({
@@ -21769,12 +22531,13 @@ var OpensteerSessionRuntime = class {
     }
   }
   async getNetworkDetail(input, options = {}) {
+    const normalizedRecordId = normalizeNetworkRecordId(input.recordId);
     const startedAt = Date.now();
     try {
       const output = await this.runWithOperationTimeout(
         "network.detail",
         async (timeout) => {
-          const record = await this.resolveNetworkRecordByRecordId(input.recordId, timeout, {
+          const record = await this.resolveNetworkRecordByRecordId(normalizedRecordId, timeout, {
             includeBodies: true,
             redactSecretHeaders: false
           });
@@ -21793,8 +22556,8 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "ok",
         data: {
-          recordId: input.recordId,
-          status: output.summary.status,
+          recordId: normalizedRecordId,
+          ...output.summary.status === void 0 ? {} : { status: output.summary.status },
           url: output.summary.url
         },
         context: buildRuntimeTraceContext({
@@ -23198,7 +23961,9 @@ var OpensteerSessionRuntime = class {
       ...graphql.persisted === void 0 ? {} : { persisted: graphql.persisted },
       ...graphqlVariables === void 0 ? {} : { variables: graphqlVariables }
     };
-    const requestBody = shouldShowRequestBody(record.record.method) && record.record.requestBody !== void 0 ? buildStructuredBodyPreview(record.record.requestBody, record.record.requestHeaders) : void 0;
+    const requestBody = shouldShowRequestBody(record.record.method) && record.record.requestBody !== void 0 ? buildStructuredBodyPreview(record.record.requestBody, record.record.requestHeaders, {
+      truncateData: false
+    }) : void 0;
     const responseBody = record.record.responseBody === void 0 ? void 0 : buildStructuredBodyPreview(record.record.responseBody, record.record.responseHeaders);
     const notes = detectNetworkRecordNotes(record);
     return {
@@ -23228,8 +23993,18 @@ var OpensteerSessionRuntime = class {
     let recommended;
     for (const transport of REPLAY_TRANSPORT_LADDER) {
       const attemptStartedAt = Date.now();
+      const attemptTimeoutMs = resolveReplayProbeAttemptTimeoutMs({
+        remainingMs: timeout.remainingMs(),
+        transportsRemaining: REPLAY_TRANSPORT_LADDER.length - attempts.length,
+        recommendedFound: recommended !== void 0
+      });
       try {
-        const output = await this.executeReplayTransportAttempt(transport, request, timeout);
+        const output = await this.executeReplayTransportAttemptWithinBudget(
+          transport,
+          request,
+          timeout,
+          attemptTimeoutMs
+        );
         const ok = matchesSuccessFingerprintFromProtocolResponse(output.response, fingerprint);
         attempts.push({
           transport,
@@ -23245,7 +24020,7 @@ var OpensteerSessionRuntime = class {
           transport,
           ok: false,
           durationMs: Date.now() - attemptStartedAt,
-          error: normalizeRuntimeErrorMessage(error)
+          error: normalizeProbeTransportAttemptError(transport, error, attemptTimeoutMs)
         });
       }
     }
@@ -23449,6 +24224,23 @@ var OpensteerSessionRuntime = class {
       }
     }
   }
+  async executeReplayTransportAttemptWithinBudget(transport, request, timeout, attemptTimeoutMs) {
+    if (attemptTimeoutMs === void 0) {
+      return this.executeReplayTransportAttempt(transport, request, timeout);
+    }
+    return runWithPolicyTimeout(
+      {
+        resolveTimeoutMs() {
+          return attemptTimeoutMs;
+        }
+      },
+      {
+        operation: timeout.operation,
+        signal: timeout.signal
+      },
+      (attemptTimeout) => this.executeReplayTransportAttempt(transport, request, attemptTimeout)
+    );
+  }
   async executeFetchTransportAttempt(transport, request, timeout, input) {
     let prepared = finalizeMaterializedTransportRequest(request, transport);
     if (input.cookies !== false && transport === "direct-http" && this.currentBinding() !== void 0) {
@@ -24363,10 +25155,15 @@ var OpensteerSessionRuntime = class {
     return this.observationSessionId ?? this.sessionRef;
   }
   runWithOperationTimeout(operation, callback, options = {}) {
+    const timeoutPolicy = options.timeoutMs === void 0 ? this.policy.timeout : {
+      resolveTimeoutMs() {
+        return options.timeoutMs;
+      }
+    };
     const existingCollector = this.operationEventStorage.getStore();
     if (existingCollector !== void 0) {
       return runWithPolicyTimeout(
-        this.policy.timeout,
+        timeoutPolicy,
         {
           operation,
           ...options.signal === void 0 ? {} : { signal: options.signal }
@@ -24379,7 +25176,7 @@ var OpensteerSessionRuntime = class {
     return this.operationEventStorage.run(collector, async () => {
       try {
         return await runWithPolicyTimeout(
-          this.policy.timeout,
+          timeoutPolicy,
           {
             operation,
             ...options.signal === void 0 ? {} : { signal: options.signal }
@@ -24549,6 +25346,21 @@ function buildEngineNetworkRecordFilters(input) {
 function normalizeNetworkStatusFilter(status) {
   return String(status);
 }
+function normalizeNetworkQueryInput(input) {
+  return {
+    ...input,
+    ...input.recordId === void 0 ? {} : { recordId: normalizeNetworkRecordId(input.recordId) },
+    ...input.before === void 0 ? {} : { before: normalizeNetworkRecordId(input.before) },
+    ...input.after === void 0 ? {} : { after: normalizeNetworkRecordId(input.after) }
+  };
+}
+function normalizeNetworkRecordId(recordId) {
+  const trimmed = recordId.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("record:")) {
+    return trimmed;
+  }
+  return `record:${trimmed}`;
+}
 function resolveLiveQueryRequestIds(input, history) {
   const requestIdCandidates = [];
   if (input.recordId !== void 0) {
@@ -24761,6 +25573,20 @@ var REPLAY_TRANSPORT_LADDER = [
   "context-http",
   "page-http"
 ];
+function resolveReplayProbeAttemptTimeoutMs(input) {
+  const attemptCapMs = input.recommendedFound ? REPLAY_PROBE_POST_SUCCESS_ATTEMPT_TIMEOUT_MS : REPLAY_PROBE_MAX_ATTEMPT_TIMEOUT_MS;
+  const clampedRemaining = input.remainingMs === void 0 ? void 0 : Math.max(0, input.remainingMs);
+  if (clampedRemaining === 0) {
+    return 0;
+  }
+  if (clampedRemaining === void 0) {
+    return attemptCapMs;
+  }
+  const sliceMs = Math.floor(clampedRemaining / Math.max(1, input.transportsRemaining));
+  const minimumBudgetAffordable = clampedRemaining >= REPLAY_PROBE_MIN_ATTEMPT_TIMEOUT_MS * input.transportsRemaining;
+  const attemptBudgetMs = minimumBudgetAffordable ? Math.max(REPLAY_PROBE_MIN_ATTEMPT_TIMEOUT_MS, sliceMs) : sliceMs;
+  return Math.min(clampedRemaining, attemptCapMs, Math.max(1, attemptBudgetMs));
+}
 function filterNetworkSummaryRecords(records, input) {
   return records.filter((record) => {
     if (record.record.resourceType === "preflight" || record.record.method === "OPTIONS") {
@@ -24933,10 +25759,10 @@ function extractGraphqlOperationName(queryText) {
 function shouldShowRequestBody(method) {
   return !["GET", "HEAD", "DELETE", "OPTIONS"].includes(method.trim().toUpperCase());
 }
-function buildStructuredBodyPreview(body, headers) {
+function buildStructuredBodyPreview(body, headers, options = {}) {
   const contentType = headerValue(headers, "content-type") ?? body?.mimeType;
   const parsed = parseStructuredPayload(body, contentType);
-  const data = parsed === void 0 ? void 0 : typeof parsed === "string" ? truncateInlineText(parsed) : truncateStructuredValue(parsed);
+  const data = parsed === void 0 ? void 0 : options.truncateData === false ? parsed : typeof parsed === "string" ? truncateInlineText(parsed) : truncateStructuredValue(parsed);
   return {
     bytes: body?.originalByteLength ?? body?.capturedByteLength ?? 0,
     ...contentType === void 0 ? {} : { contentType },
@@ -25149,10 +25975,12 @@ function resolveSessionFetchTransportLadder(transport) {
       return ["direct-http"];
     case "matched-tls":
       return ["matched-tls"];
+    case "context":
+      return ["context-http"];
     case "page":
       return ["page-http"];
     case "auto":
-      return ["direct-http", "matched-tls", "page-http"];
+      return ["direct-http", "matched-tls", "context-http", "page-http"];
   }
 }
 function detectChallengeNoteFromRecord(record) {
@@ -25297,6 +26125,12 @@ function diffStorageSnapshot(left, right) {
 function normalizeRuntimeErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function normalizeProbeTransportAttemptError(transport, error, attemptTimeoutMs) {
+  if (attemptTimeoutMs !== void 0 && error instanceof OpensteerProtocolError && error.code === "timeout") {
+    return `${transport} probe exceeded ${String(attemptTimeoutMs)}ms`;
+  }
+  return normalizeRuntimeErrorMessage(error);
+}
 function applyBrowserCookiesToTransportRequest(request, cookies) {
   if (cookies.length === 0) {
     return request;
@@ -26064,10 +26898,10 @@ var OpensteerSemanticRestClient = class {
   constructor(connection) {
     this.connection = connection;
   }
-  async invoke(operation, input) {
-    return this.invokeInternal(operation, input, false);
+  async invoke(operation, input, options = {}) {
+    return this.invokeInternal(operation, input, false, options);
   }
-  async invokeInternal(operation, input, hasRetried) {
+  async invokeInternal(operation, input, hasRetried, options) {
     const endpoint = opensteerSemanticRestEndpoints.find((entry) => entry.name === operation);
     if (!endpoint) {
       throw new Error(`unsupported semantic operation ${operation}`);
@@ -26081,10 +26915,11 @@ var OpensteerSemanticRestClient = class {
         method: "POST",
         headers: {
           authorization: await this.connection.getAuthorizationHeader(),
-          "content-type": "application/json; charset=utf-8"
+          "content-type": "application/json; charset=utf-8",
+          ...options.timeoutMs === void 0 ? {} : { "x-opensteer-timeout-ms": String(options.timeoutMs) }
         },
         body: JSON.stringify(request),
-        signal: AbortSignal.timeout(3e4)
+        signal: createRequestSignal2(options)
       });
     } catch (error) {
       if (operation === "session.close" && isFetchFailure(error)) {
@@ -26100,7 +26935,7 @@ var OpensteerSemanticRestClient = class {
       return envelope.data;
     } catch (error) {
       if (!hasRetried && this.connection.handleError && await this.connection.handleError(error, { operation })) {
-        return this.invokeInternal(operation, input, true);
+        return this.invokeInternal(operation, input, true, options);
       }
       if (operation === "session.close" && isFetchFailure(error)) {
         return { closed: true };
@@ -26112,6 +26947,13 @@ var OpensteerSemanticRestClient = class {
     return this.invoke("session.close", {});
   }
 };
+function createRequestSignal2(options) {
+  const timeoutSignal = AbortSignal.timeout(options.timeoutMs ?? 3e4);
+  if (options.signal === void 0) {
+    return timeoutSignal;
+  }
+  return AbortSignal.any([options.signal, timeoutSignal]);
+}
 function isFetchFailure(error) {
   if (!(error instanceof Error)) {
     return false;
@@ -26478,13 +27320,44 @@ function asRecord(value) {
   return value;
 }
 
-// src/cloud/registry-sync.ts
-var REGISTRY_SYNC_MAX_PAYLOAD_BYTES = 15e5;
-var REGISTRY_SYNC_MAX_ENTRIES_PER_BATCH = 100;
-async function syncLocalRegistryToCloud(client, workspace, store) {
+// src/cloud/workspace-sync.ts
+var WORKSPACE_SYNC_MAX_PAYLOAD_BYTES = 15e5;
+var WORKSPACE_SYNC_MAX_ENTRIES_PER_BATCH = 100;
+async function syncLocalWorkspaceToCloud(client, workspace, store) {
+  await syncDescriptorRegistryToCloud(client, workspace, store);
+  await syncRequestPlansToCloud(client, workspace, store);
+}
+async function syncDescriptorRegistryToCloud(client, workspace, store) {
   const descriptors = await store.registry.descriptors.list();
-  const descriptorEntries = descriptors.map((record) => toDescriptorImportEntry(workspace, record));
-  await importInBatches(descriptorEntries, (entries) => client.importDescriptors(entries));
+  const entries = descriptors.map((record) => toDescriptorImportEntry(workspace, record));
+  await importInBatches(entries, {
+    getPayloadByteLength: (batch) => payloadByteLength({ entries: batch }),
+    importBatch: (batch) => client.importDescriptors(batch)
+  });
+}
+async function syncRequestPlansToCloud(client, workspace, store) {
+  const requestPlans = await store.registry.requestPlans.list();
+  const entries = requestPlans.map((record) => toRequestPlanImportEntry(workspace, record)).filter((entry) => entry !== void 0);
+  await importInBatches(entries, {
+    getPayloadByteLength: (batch) => payloadByteLength({ entries: batch }),
+    importBatch: (batch) => client.importRequestPlans({ entries: batch })
+  });
+}
+function toRequestPlanImportEntry(workspace, record) {
+  const entry = {
+    workspace,
+    recordId: record.id,
+    key: record.key,
+    version: record.version,
+    contentHash: record.contentHash,
+    tags: [...record.tags],
+    ...record.provenance === void 0 ? {} : { provenance: record.provenance },
+    ...record.freshness === void 0 ? {} : { freshness: record.freshness },
+    payload: record.payload,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  };
+  return payloadByteLength({ entries: [entry] }) <= WORKSPACE_SYNC_MAX_PAYLOAD_BYTES ? entry : void 0;
 }
 function toDescriptorImportEntry(workspace, record) {
   return {
@@ -26500,19 +27373,19 @@ function toDescriptorImportEntry(workspace, record) {
     updatedAt: record.updatedAt
   };
 }
-async function importInBatches(entries, importBatch) {
+async function importInBatches(entries, options) {
   if (entries.length === 0) {
     return;
   }
-  for (const batch of chunkEntries(entries)) {
-    await importBatch(batch);
+  for (const batch of chunkEntries(entries, options.getPayloadByteLength)) {
+    await options.importBatch(batch);
   }
 }
-function chunkEntries(entries) {
+function chunkEntries(entries, getPayloadByteLength) {
   const batches = [];
   let currentBatch = [];
   for (const entry of entries) {
-    if (payloadByteLength([entry]) > REGISTRY_SYNC_MAX_PAYLOAD_BYTES) {
+    if (getPayloadByteLength([entry]) > WORKSPACE_SYNC_MAX_PAYLOAD_BYTES) {
       continue;
     }
     if (currentBatch.length === 0) {
@@ -26520,7 +27393,7 @@ function chunkEntries(entries) {
       continue;
     }
     const nextBatch = [...currentBatch, entry];
-    if (nextBatch.length > REGISTRY_SYNC_MAX_ENTRIES_PER_BATCH || payloadByteLength(nextBatch) > REGISTRY_SYNC_MAX_PAYLOAD_BYTES) {
+    if (nextBatch.length > WORKSPACE_SYNC_MAX_ENTRIES_PER_BATCH || getPayloadByteLength(nextBatch) > WORKSPACE_SYNC_MAX_PAYLOAD_BYTES) {
       batches.push(currentBatch);
       currentBatch = [entry];
       continue;
@@ -26532,8 +27405,8 @@ function chunkEntries(entries) {
   }
   return batches;
 }
-function payloadByteLength(entries) {
-  return Buffer.byteLength(JSON.stringify({ entries }), "utf8");
+function payloadByteLength(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
 }
 
 // src/cloud/session-proxy.ts
@@ -26544,30 +27417,36 @@ var CloudSessionProxy = class {
   cleanupRootOnClose;
   cloud;
   observability;
+  policy;
   sessionId;
   semanticGrant;
   client;
   automation;
   workspaceStore;
+  syncWorkspaceOnClose = false;
   constructor(cloud, options = {}) {
     this.cloud = cloud;
     this.workspace = options.workspace;
+    this.policy = options.policy ?? defaultPolicy();
     this.observability = options.observability;
-    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7__default.default.join(os.tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
-      rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path10__default.default.join(os.tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
+      rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
       workspace: this.workspace
     }));
     this.cleanupRootOnClose = options.cleanupRootOnClose ?? this.workspace === void 0;
   }
   async open(input = {}) {
-    await this.ensureSession({
-      ...input.browser === void 0 ? {} : { browser: input.browser },
-      ...input.launch === void 0 ? {} : { launch: input.launch },
-      ...input.context === void 0 ? {} : { context: input.context }
-    });
-    return this.requireClient().invoke("session.open", {
-      ...input.url === void 0 ? {} : { url: input.url }
-    });
+    return this.invokeSemanticOperation(
+      "session.open",
+      {
+        ...input.url === void 0 ? {} : { url: input.url }
+      },
+      {
+        ...input.browser === void 0 ? {} : { browser: input.browser },
+        ...input.launch === void 0 ? {} : { launch: input.launch },
+        ...input.context === void 0 ? {} : { context: input.context }
+      }
+    );
   }
   async info() {
     const persisted = this.client !== void 0 || this.sessionId !== void 0 ? void 0 : await this.loadPersistedSession();
@@ -26610,108 +27489,88 @@ var CloudSessionProxy = class {
     };
   }
   async listPages(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.list", input);
+    return this.invokeSemanticOperation("page.list", input);
   }
   async newPage(input = {}) {
-    await this.ensureSession();
-    return this.requireAutomation().invoke("page.new", input);
+    return this.invokeAutomationOperation(
+      "page.new",
+      (automation) => automation.invoke("page.new", input)
+    );
   }
   async activatePage(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.activate", input);
+    return this.invokeSemanticOperation("page.activate", input);
   }
   async closePage(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.close", input);
+    return this.invokeSemanticOperation("page.close", input);
   }
   async goto(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.goto", input);
+    return this.invokeSemanticOperation("page.goto", input);
   }
   async evaluate(input) {
-    await this.ensureSession();
-    return this.requireAutomation().invoke("page.evaluate", input);
+    return this.invokeAutomationOperation(
+      "page.evaluate",
+      (automation) => automation.invoke("page.evaluate", input)
+    );
   }
   async addInitScript(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.add-init-script", input);
+    return this.invokeSemanticOperation("page.add-init-script", input);
   }
   async snapshot(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.snapshot", input);
+    return this.invokeSemanticOperation("page.snapshot", input);
   }
   async click(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.click", input);
+    return this.invokeSemanticOperation("dom.click", input);
   }
   async hover(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.hover", input);
+    return this.invokeSemanticOperation("dom.hover", input);
   }
   async input(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.input", input);
+    return this.invokeSemanticOperation("dom.input", input);
   }
   async scroll(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.scroll", input);
+    return this.invokeSemanticOperation("dom.scroll", input);
   }
   async extract(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.extract", input);
+    return this.invokeSemanticOperation("dom.extract", input);
   }
   async queryNetwork(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("network.query", input);
+    return this.invokeSemanticOperation("network.query", input);
   }
   async getNetworkDetail(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("network.detail", input);
+    return this.invokeSemanticOperation("network.detail", input);
   }
   async captureInteraction(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("interaction.capture", input);
+    return this.invokeSemanticOperation("interaction.capture", input);
   }
   async getInteraction(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("interaction.get", input);
+    return this.invokeSemanticOperation("interaction.get", input);
   }
   async diffInteraction(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("interaction.diff", input);
+    return this.invokeSemanticOperation("interaction.diff", input);
   }
   async replayInteraction(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("interaction.replay", input);
+    return this.invokeSemanticOperation("interaction.replay", input);
   }
   async captureScripts(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("scripts.capture", input);
+    return this.invokeSemanticOperation("scripts.capture", input);
   }
   async readArtifact(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("artifact.read", input);
+    return this.invokeSemanticOperation("artifact.read", input);
   }
   async beautifyScript(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("scripts.beautify", input);
+    return this.invokeSemanticOperation("scripts.beautify", input);
   }
   async deobfuscateScript(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("scripts.deobfuscate", input);
+    return this.invokeSemanticOperation("scripts.deobfuscate", input);
   }
   async sandboxScript(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("scripts.sandbox", input);
+    return this.invokeSemanticOperation("scripts.sandbox", input);
   }
   async solveCaptcha(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("captcha.solve", input);
+    return this.invokeSemanticOperation("captcha.solve", input);
   }
   async getCookies(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("session.cookies", input);
+    return this.invokeSemanticOperation("session.cookies", input);
   }
   async route(input) {
     await this.ensureSession();
@@ -26722,20 +27581,16 @@ var CloudSessionProxy = class {
     return this.requireAutomation().interceptScript(input);
   }
   async getStorageSnapshot(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("session.storage", input);
+    return this.invokeSemanticOperation("session.storage", input);
   }
   async getBrowserState(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("session.state", input);
+    return this.invokeSemanticOperation("session.state", input);
   }
   async fetch(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("session.fetch", input);
+    return this.invokeSemanticOperation("session.fetch", input);
   }
   async computerExecute(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("computer.execute", input);
+    return this.invokeSemanticOperation("computer.execute", input);
   }
   async close() {
     const session = await this.loadPersistedSession() ?? (this.sessionId === void 0 ? void 0 : {
@@ -26747,6 +27602,14 @@ var CloudSessionProxy = class {
       startedAt: Date.now(),
       updatedAt: Date.now()
     });
+    let syncError;
+    if (this.syncWorkspaceOnClose) {
+      try {
+        await this.syncWorkspaceToCloud();
+      } catch (error) {
+        syncError = error;
+      }
+    }
     try {
       if (session !== void 0) {
         await this.cloud.closeSession(session.sessionId).catch((error) => {
@@ -26767,6 +27630,9 @@ var CloudSessionProxy = class {
         await promises.rm(this.rootPath, { recursive: true, force: true }).catch(() => void 0);
       }
     }
+    if (syncError !== void 0) {
+      throw syncError;
+    }
     return { closed: true };
   }
   async disconnect() {
@@ -26774,34 +27640,38 @@ var CloudSessionProxy = class {
       await this.close();
       return;
     }
+    let syncError;
+    if (this.syncWorkspaceOnClose) {
+      try {
+        await this.syncWorkspaceToCloud();
+      } catch (error) {
+        syncError = error;
+      }
+    }
     this.client = void 0;
     await this.automation?.close().catch(() => void 0);
     this.automation = void 0;
     this.sessionId = void 0;
     this.semanticGrant = void 0;
+    if (syncError !== void 0) {
+      throw syncError;
+    }
   }
-  async ensureSession(input = {}) {
+  async ensureSession(input = {}, timeout) {
     if (this.client) {
       return;
     }
     assertSupportedCloudBrowserMode(input.browser);
     const localCloud = this.shouldUseLocalCloudTransport();
+    this.syncWorkspaceOnClose = localCloud && this.workspace !== void 0;
     const browserProfile = resolveCloudBrowserProfile(this.cloud, input);
     const persisted = await this.loadPersistedSession();
-    if (persisted !== void 0 && await this.isReusableCloudSession(persisted.sessionId)) {
-      if (localCloud) {
-        void this.syncRegistryToCloud();
-      } else {
-        await this.syncRegistryToCloud();
-      }
+    if (persisted !== void 0 && await this.isReusableCloudSession(persisted.sessionId, timeout)) {
+      await this.syncWorkspaceToCloud();
       this.bindClient(persisted);
       return;
     }
-    if (localCloud) {
-      void this.syncRegistryToCloud();
-    } else {
-      await this.syncRegistryToCloud();
-    }
+    await this.syncWorkspaceToCloud();
     const baseCreateInput = {
       ...this.workspace === void 0 ? {} : { name: this.workspace },
       ...input.launch === void 0 ? {} : { browser: input.launch },
@@ -26813,10 +27683,12 @@ var CloudSessionProxy = class {
       ...baseCreateInput,
       sourceType: "local-cloud",
       sourceRef: this.workspace,
-      localWorkspaceRootPath: this.rootPath,
-      locality: "auto"
+      localWorkspaceRootPath: this.rootPath
     } : baseCreateInput;
-    const session = await this.cloud.createSession(createInput);
+    const session = await this.cloud.createSession(createInput, {
+      signal: timeout?.signal,
+      timeoutMs: timeout?.remainingMs()
+    });
     const record = {
       layout: "opensteer-session",
       version: 1,
@@ -26829,15 +27701,12 @@ var CloudSessionProxy = class {
     await this.writePersistedSession(record);
     this.bindClient(record, session.initialGrants?.semantic);
   }
-  async syncRegistryToCloud() {
+  async syncWorkspaceToCloud() {
     if (this.workspace === void 0) {
       return;
     }
-    try {
-      const workspaceStore = await this.ensureWorkspaceStore();
-      await syncLocalRegistryToCloud(this.cloud, this.workspace, workspaceStore);
-    } catch {
-    }
+    const workspaceStore = await this.ensureWorkspaceStore();
+    await syncLocalWorkspaceToCloud(this.cloud, this.workspace, workspaceStore);
   }
   bindClient(record, initialSemanticGrant) {
     this.sessionId = record.sessionId;
@@ -26871,9 +27740,12 @@ var CloudSessionProxy = class {
   async clearPersistedSession() {
     await clearPersistedSessionRecord(this.rootPath, "cloud").catch(() => void 0);
   }
-  async isReusableCloudSession(sessionId) {
+  async isReusableCloudSession(sessionId, timeout) {
     try {
-      const session = await this.cloud.getSession(sessionId);
+      const session = await this.cloud.getSession(sessionId, {
+        signal: timeout?.signal,
+        timeoutMs: timeout?.remainingMs()
+      });
       return session.status !== "closed" && session.status !== "failed";
     } catch (error) {
       if (isMissingCloudSessionError(error)) {
@@ -26894,14 +27766,17 @@ var CloudSessionProxy = class {
     }
     return this.automation;
   }
-  async ensureSemanticGrant(forceRefresh = false) {
+  async ensureSemanticGrant(forceRefresh = false, timeout) {
     if (!forceRefresh && this.semanticGrant?.kind === "semantic" && this.semanticGrant.expiresAt > Date.now() + 1e4) {
       return this.semanticGrant;
     }
     if (!this.sessionId) {
       throw new Error("Cloud session has not been initialized.");
     }
-    const issued = await this.cloud.issueAccess(this.sessionId, ["semantic"]);
+    const issued = await this.cloud.issueAccess(this.sessionId, ["semantic"], {
+      signal: timeout?.signal,
+      timeoutMs: timeout?.remainingMs()
+    });
     const grant = issued.grants.semantic;
     if (!grant || grant.transport !== "http") {
       throw new Error("cloud did not issue a valid semantic grant");
@@ -26924,6 +27799,25 @@ var CloudSessionProxy = class {
       return false;
     }
   }
+  async invokeSemanticOperation(operation, input, sessionInit = {}) {
+    return this.runOperationWithPolicy(operation, async (timeout) => {
+      await this.ensureSession(sessionInit, timeout);
+      await this.ensureSemanticGrant(false, timeout);
+      return this.requireClient().invoke(operation, input, {
+        signal: timeout.signal,
+        timeoutMs: timeout.remainingMs()
+      });
+    });
+  }
+  async invokeAutomationOperation(operation, invoke, sessionInit = {}) {
+    return this.runOperationWithPolicy(operation, async (timeout) => {
+      await this.ensureSession(sessionInit, timeout);
+      return invoke(this.requireAutomation());
+    });
+  }
+  async runOperationWithPolicy(operation, invoke) {
+    return runWithPolicyTimeout(this.policy.timeout, { operation }, invoke);
+  }
   shouldUseLocalCloudTransport() {
     if (this.workspace === void 0) {
       return false;
@@ -26958,8 +27852,8 @@ function isLoopbackBaseUrl(baseUrl) {
 var OpensteerRuntime = class extends OpensteerSessionRuntime {
   constructor(options = {}) {
     const publicWorkspace = normalizeWorkspace2(options.workspace);
-    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path7__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
-      rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path10__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
+      rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
       workspace: publicWorkspace
     }));
     const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
@@ -26993,7 +27887,7 @@ var OpensteerRuntime = class extends OpensteerSessionRuntime {
 };
 var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
   constructor(options) {
-    const rootPath = options.rootPath ?? path7__default.default.resolve(options.rootDir ?? process.cwd());
+    const rootPath = options.rootPath ?? path10__default.default.resolve(options.rootDir ?? process.cwd());
     const cleanupRootOnClose = options.cleanupRootOnClose ?? false;
     const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
     assertSupportedEngineOptions({
@@ -27098,6 +27992,7 @@ function createOpensteerSemanticRuntime(input = {}) {
       ...runtimeOptions.rootDir === void 0 ? {} : { rootDir: runtimeOptions.rootDir },
       ...runtimeOptions.rootPath === void 0 ? {} : { rootPath: runtimeOptions.rootPath },
       ...runtimeOptions.workspace === void 0 ? {} : { workspace: runtimeOptions.workspace },
+      ...runtimeOptions.policy === void 0 ? {} : { policy: runtimeOptions.policy },
       ...runtimeOptions.cleanupRootOnClose === void 0 ? {} : { cleanupRootOnClose: runtimeOptions.cleanupRootOnClose },
       ...runtimeOptions.observability === void 0 ? {} : { observability: runtimeOptions.observability }
     });
@@ -27282,7 +28177,7 @@ var Opensteer = class {
       if (Date.now() >= timeoutAt) {
         throw new Error("waitForNetwork timed out");
       }
-      await delay2(pollInterval);
+      await delay3(pollInterval);
     }
   }
   async waitForResponse(input) {
@@ -27311,7 +28206,7 @@ var Opensteer = class {
       if (Date.now() >= timeoutAt) {
         throw new Error("waitForPage timed out");
       }
-      await delay2(pollIntervalMs);
+      await delay3(pollIntervalMs);
     }
   }
   async snapshot(mode = "action") {
@@ -27463,7 +28358,7 @@ function decodeBody(response) {
   }
   return Uint8Array.from(Buffer.from(response.body.data, "base64"));
 }
-function delay2(ms) {
+function delay3(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }