opensteer 0.8.0 → 0.8.3

package/dist/index.cjs

@@ -16,6 +16,7 @@ var cheerio = require('cheerio');
 var prettier = require('prettier');
 var vm = require('vm');
 var zlib = require('zlib');
+var WebSocket2 = require('ws');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -43,10 +44,11 @@ var sharp__default = /*#__PURE__*/_interopDefault(sharp);
 var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
 var prettier__namespace = /*#__PURE__*/_interopNamespace(prettier);
 var vm__default = /*#__PURE__*/_interopDefault(vm);
+var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
 
-// src/root.ts
+// ../runtime-core/src/root.ts
 
-// src/json.ts
+// ../runtime-core/src/json.ts
 function isPlainObject(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -54,30 +56,30 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function canonicalizeJsonValue(value, path11) {
+function canonicalizeJsonValue(value, path13) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new TypeError(`${path11} must be a finite JSON number`);
+      throw new TypeError(`${path13} must be a finite JSON number`);
     }
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path11}[${index}]`));
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path13}[${index}]`));
   }
   if (!isPlainObject(value)) {
-    throw new TypeError(`${path11} must be a plain JSON object`);
+    throw new TypeError(`${path13} 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(`${path11}.${key} must not be undefined`);
+      throw new TypeError(`${path13}.${key} must not be undefined`);
     }
-    result[key] = canonicalizeJsonValue(entry, `${path11}.${key}`);
+    result[key] = canonicalizeJsonValue(entry, `${path13}.${key}`);
   }
   return result;
 }
@@ -92,7 +94,7 @@ function stableJsonString(value) {
 `;
 }
 
-// src/internal/filesystem.ts
+// ../runtime-core/src/internal/filesystem.ts
 var LOCK_RETRY_DELAYS_MS = [1, 2, 5, 10, 20, 50];
 function normalizeNonEmptyString(name, value) {
   const normalized = value.trim();
@@ -220,7 +222,7 @@ async function withFilesystemLock(lockPath, task) {
   }
 }
 
-// src/artifacts.ts
+// ../runtime-core/src/artifacts.ts
 function normalizeScope(scope) {
   if (scope === void 0) {
     return {};
@@ -574,31 +576,31 @@ function oneOfSchema(members, options = {}) {
 }
 
 // ../protocol/src/validation.ts
-function validateJsonSchema(schema, value, path11 = "$") {
-  return validateSchemaNode(schema, value, path11);
+function validateJsonSchema(schema, value, path13 = "$") {
+  return validateSchemaNode(schema, value, path13);
 }
-function validateSchemaNode(schema, value, path11) {
+function validateSchemaNode(schema, value, path13) {
   const issues = [];
   if ("const" in schema && !isJsonValueEqual(schema.const, value)) {
     issues.push({
-      path: path11,
+      path: path13,
       message: `must equal ${JSON.stringify(schema.const)}`
     });
     return issues;
   }
   if (schema.enum !== void 0 && !schema.enum.some((candidate) => isJsonValueEqual(candidate, value))) {
     issues.push({
-      path: path11,
+      path: path13,
       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, path11));
+    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path13));
     const validBranches = branchIssues.filter((current) => current.length === 0).length;
     if (validBranches !== 1) {
       issues.push({
-        path: path11,
+        path: path13,
         message: validBranches === 0 ? "must match exactly one supported shape" : "matches multiple supported shapes"
       });
       return issues;
@@ -606,11 +608,11 @@ function validateSchemaNode(schema, value, path11) {
   }
   if (schema.anyOf !== void 0) {
     const hasMatch = schema.anyOf.some(
-      (member) => validateSchemaNode(member, value, path11).length === 0
+      (member) => validateSchemaNode(member, value, path13).length === 0
     );
     if (!hasMatch) {
       issues.push({
-        path: path11,
+        path: path13,
         message: "must match at least one supported shape"
       });
       return issues;
@@ -618,7 +620,7 @@ function validateSchemaNode(schema, value, path11) {
   }
   if (schema.allOf !== void 0) {
     for (const member of schema.allOf) {
-      issues.push(...validateSchemaNode(member, value, path11));
+      issues.push(...validateSchemaNode(member, value, path13));
     }
     if (issues.length > 0) {
       return issues;
@@ -626,7 +628,7 @@ function validateSchemaNode(schema, value, path11) {
   }
   if (schema.type !== void 0 && !matchesSchemaType(schema.type, value)) {
     issues.push({
-      path: path11,
+      path: path13,
       message: `must be ${describeSchemaType(schema.type)}`
     });
     return issues;
@@ -634,19 +636,19 @@ function validateSchemaNode(schema, value, path11) {
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must have length >= ${String(schema.minLength)}`
       });
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must have length <= ${String(schema.maxLength)}`
       });
     }
     if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must match pattern ${schema.pattern}`
       });
     }
@@ -655,25 +657,25 @@ function validateSchemaNode(schema, value, path11) {
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must be >= ${String(schema.minimum)}`
       });
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must be <= ${String(schema.maximum)}`
       });
     }
     if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must be > ${String(schema.exclusiveMinimum)}`
       });
     }
     if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must be < ${String(schema.exclusiveMaximum)}`
       });
     }
@@ -682,13 +684,13 @@ function validateSchemaNode(schema, value, path11) {
   if (Array.isArray(value)) {
     if (schema.minItems !== void 0 && value.length < schema.minItems) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must have at least ${String(schema.minItems)} items`
       });
     }
     if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must have at most ${String(schema.maxItems)} items`
       });
     }
@@ -698,7 +700,7 @@ function validateSchemaNode(schema, value, path11) {
         const key = JSON.stringify(item);
         if (seen.has(key)) {
           issues.push({
-            path: path11,
+            path: path13,
             message: "must not contain duplicate items"
           });
           break;
@@ -708,7 +710,7 @@ function validateSchemaNode(schema, value, path11) {
     }
     if (schema.items !== void 0) {
       for (let index = 0; index < value.length; index += 1) {
-        issues.push(...validateSchemaNode(schema.items, value[index], `${path11}[${String(index)}]`));
+        issues.push(...validateSchemaNode(schema.items, value[index], `${path13}[${String(index)}]`));
       }
     }
     return issues;
@@ -718,7 +720,7 @@ function validateSchemaNode(schema, value, path11) {
     for (const requiredKey of schema.required ?? []) {
       if (!(requiredKey in value)) {
         issues.push({
-          path: joinObjectPath(path11, requiredKey),
+          path: joinObjectPath(path13, requiredKey),
           message: "is required"
         });
       }
@@ -727,13 +729,13 @@ function validateSchemaNode(schema, value, path11) {
       const propertySchema = properties[key];
       if (propertySchema !== void 0) {
         issues.push(
-          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path11, key))
+          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path13, key))
         );
         continue;
       }
       if (schema.additionalProperties === false) {
         issues.push({
-          path: joinObjectPath(path11, key),
+          path: joinObjectPath(path13, key),
           message: "is not allowed"
         });
         continue;
@@ -743,7 +745,7 @@ function validateSchemaNode(schema, value, path11) {
           ...validateSchemaNode(
             schema.additionalProperties,
             propertyValue,
-            joinObjectPath(path11, key)
+            joinObjectPath(path13, key)
           )
         );
       }
@@ -987,8 +989,8 @@ function matchesNetworkRecordFilters(record, filters) {
     }
   }
   if (filters.path !== void 0) {
-    const path11 = getParsedUrl().pathname;
-    if (!includesCaseInsensitive(path11, filters.path)) {
+    const path13 = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path13, filters.path)) {
       return false;
     }
   }
@@ -5703,6 +5705,65 @@ var opensteerComputerAnnotationNames = [
   "grid",
   "selected"
 ];
+var opensteerSemanticOperationNames = [
+  "session.open",
+  "page.list",
+  "page.new",
+  "page.activate",
+  "page.close",
+  "page.goto",
+  "page.evaluate",
+  "page.add-init-script",
+  "page.snapshot",
+  "dom.click",
+  "dom.hover",
+  "dom.input",
+  "dom.scroll",
+  "dom.extract",
+  "network.query",
+  "network.save",
+  "network.clear",
+  "network.minimize",
+  "network.diff",
+  "network.probe",
+  "reverse.discover",
+  "reverse.query",
+  "reverse.package.create",
+  "reverse.package.run",
+  "reverse.export",
+  "reverse.report",
+  "reverse.package.get",
+  "reverse.package.list",
+  "reverse.package.patch",
+  "interaction.capture",
+  "interaction.get",
+  "interaction.diff",
+  "interaction.replay",
+  "artifact.read",
+  "inspect.cookies",
+  "inspect.storage",
+  "scripts.capture",
+  "scripts.beautify",
+  "scripts.deobfuscate",
+  "scripts.sandbox",
+  "captcha.solve",
+  "request.raw",
+  "request-plan.infer",
+  "request-plan.write",
+  "request-plan.get",
+  "request-plan.list",
+  "recipe.write",
+  "recipe.get",
+  "recipe.list",
+  "recipe.run",
+  "auth-recipe.write",
+  "auth-recipe.get",
+  "auth-recipe.list",
+  "auth-recipe.run",
+  "request.execute",
+  "computer.execute",
+  "session.close"
+];
 function defineSemanticOperationSpec(spec) {
   return spec;
 }
@@ -7002,7 +7063,7 @@ function resolveDomActionBridge(engine) {
   return isDomActionBridgeFactory(candidate) ? candidate.call(engine) : void 0;
 }
 
-// src/registry.ts
+// ../runtime-core/src/registry.ts
 function normalizeTags(tags) {
   if (tags === void 0) {
     return [];
@@ -8236,7 +8297,7 @@ function createTraceStore(rootPath, artifacts) {
   return new FilesystemTraceStore(rootPath, artifacts);
 }
 
-// src/root.ts
+// ../runtime-core/src/root.ts
 var OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT = "opensteer-workspace";
 var OPENSTEER_FILESYSTEM_WORKSPACE_VERSION = 2;
 function normalizeWorkspaceId(workspace) {
@@ -8257,6 +8318,7 @@ async function createFilesystemOpensteerWorkspace(options) {
   const browserManifestPath = path6__default.default.join(browserPath, "manifest.json");
   const browserUserDataDir = path6__default.default.join(browserPath, "user-data");
   const livePath = path6__default.default.join(options.rootPath, "live");
+  const liveSessionPath = path6__default.default.join(livePath, "session.json");
   const liveBrowserPath = path6__default.default.join(livePath, "browser.json");
   const artifactsPath = path6__default.default.join(options.rootPath, "artifacts");
   const tracesPath = path6__default.default.join(options.rootPath, "traces");
@@ -8332,6 +8394,7 @@ async function createFilesystemOpensteerWorkspace(options) {
     browserManifestPath,
     browserUserDataDir,
     livePath,
+    liveSessionPath,
     liveBrowserPath,
     artifactsPath,
     tracesPath,
@@ -8356,7 +8419,7 @@ async function createFilesystemOpensteerWorkspace(options) {
   };
 }
 
-// src/policy/defaults.ts
+// ../runtime-core/src/policy/defaults.ts
 var DEFAULT_TIMEOUTS = {
   "session.open": 3e4,
   "page.goto": 3e4,
@@ -8439,7 +8502,7 @@ function defaultPolicy() {
   return DEFAULT_POLICY;
 }
 
-// src/policy/settle.ts
+// ../runtime-core/src/policy/settle.ts
 async function settleWithPolicy(policy, input) {
   for (const observer of policy.observers ?? []) {
     if (await observer.settle(input)) {
@@ -8478,7 +8541,7 @@ function abortError() {
   return error;
 }
 
-// src/policy/timeout.ts
+// ../runtime-core/src/policy/timeout.ts
 var PolicyTimeoutController = class {
   constructor(input, budgetMs) {
     this.input = input;
@@ -8588,7 +8651,7 @@ function abortError2() {
   return error;
 }
 
-// src/runtimes/dom/match-policy.ts
+// ../runtime-core/src/runtimes/dom/match-policy.ts
 var ATTRIBUTE_DENY_KEYS = /* @__PURE__ */ new Set([
   "style",
   "nonce",
@@ -8820,7 +8883,7 @@ function getClauseAttributeValue(node, clause) {
   return String(raw);
 }
 
-// src/runtimes/dom/match-selectors.ts
+// ../runtime-core/src/runtimes/dom/match-selectors.ts
 function buildPathCandidates(domPath) {
   const nodes = Array.isArray(domPath) ? domPath : [];
   if (!nodes.length) {
@@ -8905,7 +8968,7 @@ function buildSuffixCandidates(segments) {
   return out;
 }
 
-// src/runtimes/dom/extraction.ts
+// ../runtime-core/src/runtimes/dom/extraction.ts
 var URL_LIST_ATTRIBUTES = /* @__PURE__ */ new Set(["srcset", "imagesrcset", "ping"]);
 var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "href",
@@ -8917,9 +8980,9 @@ var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "poster",
   "ping"
 ]);
-function buildArrayFieldPathCandidates(path11) {
-  const strict = path11.nodes.length ? buildPathCandidates(path11.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path11.nodes);
+function buildArrayFieldPathCandidates(path13) {
+  const strict = path13.nodes.length ? buildPathCandidates(path13.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path13.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -9152,7 +9215,7 @@ function readDescriptorToken(value, index) {
   };
 }
 
-// src/runtimes/dom/errors.ts
+// ../runtime-core/src/runtimes/dom/errors.ts
 var ElementPathError = class extends Error {
   code;
   constructor(code, message) {
@@ -9228,6 +9291,45 @@ var selectorAdapter = {
   },
   equals(left, right) {
     return left === right;
+  },
+  existsOne(test, nodes) {
+    return selectorAdapter.findOne(test, nodes) !== null;
+  },
+  findAll(test, nodes) {
+    const matches = [];
+    const visit = (node) => {
+      if (selectorAdapter.isTag(node) && test(node)) {
+        matches.push(node);
+      }
+      for (const child of selectorAdapter.getChildren(node)) {
+        visit(child);
+      }
+    };
+    for (const node of nodes) {
+      visit(node);
+    }
+    return matches;
+  },
+  findOne(test, nodes) {
+    const visit = (node) => {
+      if (selectorAdapter.isTag(node) && test(node)) {
+        return node;
+      }
+      for (const child of selectorAdapter.getChildren(node)) {
+        const match = visit(child);
+        if (match !== null) {
+          return match;
+        }
+      }
+      return null;
+    };
+    for (const node of nodes) {
+      const match = visit(node);
+      if (match !== null) {
+        return match;
+      }
+    }
+    return null;
   }
 };
 function createDomSnapshotIndex(snapshot) {
@@ -9411,7 +9513,7 @@ function sortNodes(nodes) {
   return [...nodes].sort((left, right) => left.snapshotNodeId - right.snapshotNodeId);
 }
 
-// src/runtimes/dom/path.ts
+// ../runtime-core/src/runtimes/dom/path.ts
 var MAX_ATTRIBUTE_VALUE_LENGTH = 300;
 function cloneStructuralElementAnchor(anchor) {
   return {
@@ -9420,18 +9522,18 @@ function cloneStructuralElementAnchor(anchor) {
     nodes: anchor.nodes.map(clonePathNode)
   };
 }
-function cloneReplayElementPath(path11) {
+function cloneReplayElementPath(path13) {
   return {
     resolution: "deterministic",
-    context: cloneContext(path11.context),
-    nodes: path11.nodes.map(clonePathNode)
+    context: cloneContext(path13.context),
+    nodes: path13.nodes.map(clonePathNode)
   };
 }
-function cloneElementPath(path11) {
-  return cloneReplayElementPath(path11);
+function cloneElementPath(path13) {
+  return cloneReplayElementPath(path13);
 }
-function buildPathSelectorHint(path11) {
-  const nodes = path11?.nodes || [];
+function buildPathSelectorHint(path13) {
+  const nodes = path13?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) {
     return "*";
@@ -9480,15 +9582,15 @@ function sanitizeStructuralElementAnchor(anchor) {
     nodes: sanitizeNodes(anchor.nodes)
   };
 }
-function sanitizeReplayElementPath(path11) {
+function sanitizeReplayElementPath(path13) {
   return {
     resolution: "deterministic",
-    context: sanitizeContext(path11.context),
-    nodes: sanitizeNodes(path11.nodes)
+    context: sanitizeContext(path13.context),
+    nodes: sanitizeNodes(path13.nodes)
   };
 }
-function sanitizeElementPath(path11) {
-  return sanitizeReplayElementPath(path11);
+function sanitizeElementPath(path13) {
+  return sanitizeReplayElementPath(path13);
 }
 function buildLocalStructuralElementAnchor(index, rawTargetNode) {
   const targetNode = requireElementNode(index, rawTargetNode);
@@ -9611,8 +9713,8 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
   }
   return `${base} Target depth ${String(depth)}. Candidate counts: ${sample}.`;
 }
-function buildArrayFieldCandidates(path11) {
-  return buildArrayFieldPathCandidates(path11);
+function buildArrayFieldCandidates(path13) {
+  return buildArrayFieldPathCandidates(path13);
 }
 function firstDefinedAttribute(node, keys) {
   for (const key of keys) {
@@ -10028,7 +10130,7 @@ var MemoryDomDescriptorStore = class {
   }
 };
 
-// src/runtimes/dom/executor.ts
+// ../runtime-core/src/runtimes/dom/executor.ts
 var MAX_DOM_ACTION_ATTEMPTS = 3;
 var DEFAULT_SCROLL_OPTIONS = {
   block: "center",
@@ -10592,7 +10694,7 @@ function pointFallsWithinQuads(point, quads) {
   return quads.some((quad) => rectContainsPoint(quadBounds(quad), point));
 }
 
-// src/runtimes/dom/runtime.ts
+// ../runtime-core/src/runtimes/dom/runtime.ts
 var SnapshotSession = class {
   constructor(engine) {
     this.engine = engine;
@@ -10996,21 +11098,21 @@ var DefaultDomRuntime = class {
     return match;
   }
   async resolvePathTarget(session, pageRef, rawPath, source, description, descriptor) {
-    const path11 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path11.context);
-    const target = resolveDomPathInScope(context.index, path11.nodes, context.scope);
+    const path13 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path13.context);
+    const target = resolveDomPathInScope(context.index, path13.nodes, context.scope);
     if (!target) {
-      throwTargetNotFound(context.index, path11.nodes, context.scope);
+      throwTargetNotFound(context.index, path13.nodes, context.scope);
     }
     if (target.node.nodeRef === void 0) {
       throw new Error(
-        `resolved path "${buildPathSelectorHint(path11)}" does not point to a live element`
+        `resolved path "${buildPathSelectorHint(path13)}" 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, {
       ...description === void 0 ? {} : { description },
-      replayPath: path11,
+      replayPath: path13,
       ...source === "path" || source === "descriptor" ? { selectorUsed: target.selector } : {},
       ...descriptor === void 0 ? {} : { descriptor }
     });
@@ -11031,9 +11133,9 @@ var DefaultDomRuntime = class {
     });
   }
   async queryAllByElementPath(session, pageRef, rawPath) {
-    const path11 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path11.context);
-    return queryAllDomPathInScope(context.index, path11.nodes, context.scope).filter(
+    const path13 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path13.context);
+    return queryAllDomPathInScope(context.index, path13.nodes, context.scope).filter(
       (node) => node.nodeRef !== void 0
     ).map((node) => this.createSnapshotTarget(context.snapshot, node));
   }
@@ -11219,16 +11321,16 @@ var DefaultDomRuntime = class {
     const index = createSnapshotIndex(item.snapshot);
     return this.resolveFirstArrayFieldTargetInNode(index, item.node, field.path);
   }
-  resolveFirstArrayFieldTargetInNode(index, rootNode, path11) {
-    const normalizedPath = sanitizeElementPath(path11);
+  resolveFirstArrayFieldTargetInNode(index, rootNode, path13) {
+    const normalizedPath = sanitizeElementPath(path13);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
     }
     return resolveFirstWithinNodeBySelectors(index, rootNode, selectors);
   }
-  resolveUniqueArrayFieldTargetInNode(index, rootNode, path11) {
-    const normalizedPath = sanitizeElementPath(path11);
+  resolveUniqueArrayFieldTargetInNode(index, rootNode, path13) {
+    const normalizedPath = sanitizeElementPath(path13);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
@@ -11316,6 +11418,32 @@ async function clearChromeSingletonEntries(userDataDir) {
     )
   );
 }
+async function sanitizeChromeProfile(userDataDir) {
+  const entries = await promises.readdir(userDataDir).catch(() => []);
+  const profileDirs = entries.filter(
+    (entry) => entry === "Default" || /^Profile \d+$/i.test(entry)
+  );
+  await Promise.all(profileDirs.map((dir) => sanitizeProfilePreferences(userDataDir, dir)));
+}
+async function sanitizeProfilePreferences(userDataDir, profileDir) {
+  const prefsPath = path6.join(userDataDir, profileDir, "Preferences");
+  try {
+    const raw = await promises.readFile(prefsPath, "utf8");
+    const prefs = JSON.parse(raw);
+    const profile = prefs.profile ?? {};
+    if (profile.exit_type === "Normal" && profile.exited_cleanly === true) {
+      return;
+    }
+    profile.exit_type = "Normal";
+    profile.exited_cleanly = true;
+    prefs.profile = profile;
+    await promises.writeFile(prefsPath, JSON.stringify(prefs), "utf8");
+    await promises.rm(path6.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
+      () => void 0
+    );
+  } catch {
+  }
+}
 var PROCESS_LIST_MAX_BUFFER_BYTES2 = 16 * 1024 * 1024;
 var PS_COMMAND_ENV2 = { ...process.env, LC_ALL: "C" };
 var WINDOWS_PROGRAM_FILES = process.env.PROGRAMFILES ?? "C:\\Program Files";
@@ -12069,8 +12197,8 @@ function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
   const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
   return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
 }
-function normalizeWebSocketPath(path11) {
-  return path11.startsWith("/") ? path11 : `/${path11}`;
+function normalizeWebSocketPath(path13) {
+  return path13.startsWith("/") ? path13 : `/${path13}`;
 }
 function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
   try {
@@ -12145,6 +12273,7 @@ async function createBrowserProfileSnapshot(input) {
     ...profileDirectory === void 0 ? {} : { selectedProfileDirectory: profileDirectory }
   });
   await clearChromeSingletonEntries(targetUserDataDir);
+  await sanitizeChromeProfile(targetUserDataDir);
 }
 async function copyRootLevelEntries(input) {
   const entries = await promises.readdir(input.sourceUserDataDir).catch(() => []);
@@ -12205,17 +12334,28 @@ function shouldCopyEntry(input) {
 
 // src/local-browser/stealth-init-script.ts
 function generateStealthInitScript(profile) {
-  const encodedProfile = JSON.stringify(profile);
+  const encodedProfile = JSON.stringify({
+    ...profile,
+    platformString: getPlatformString(profile.platform),
+    userAgentData: buildUserAgentData(profile)
+  });
   return `(() => {
   const profile = ${encodedProfile};
-  const define = (target, key, value) => {
+  var define = function(target, key, value) {
     Object.defineProperty(target, key, {
       configurable: true,
-      get: typeof value === "function" ? value : () => value,
+      get: typeof value === 'function' ? value : function() { return value; },
     });
   };
-  define(Navigator.prototype, 'webdriver', false);
-  define(Navigator.prototype, 'platform', profile.platform === 'macos' ? 'MacIntel' : profile.platform === 'windows' ? 'Win32' : 'Linux x86_64');
+
+  // --- navigator / screen mirrors for future pages ---
+  if (navigator.webdriver === true) {
+    Object.defineProperty(Navigator.prototype, 'webdriver', {
+      configurable: true,
+      get: function() { return false; },
+    });
+  }
+  define(Navigator.prototype, 'platform', profile.platformString);
   define(Navigator.prototype, 'userAgent', profile.userAgent);
   define(Navigator.prototype, 'language', profile.locale);
   define(Navigator.prototype, 'languages', [profile.locale, 'en']);
@@ -12225,53 +12365,191 @@ function generateStealthInitScript(profile) {
   define(window.screen, 'height', profile.screenResolution.height);
   define(window.screen, 'availWidth', profile.screenResolution.width);
   define(window.screen, 'availHeight', profile.screenResolution.height - 40);
-  if (document.fonts && typeof document.fonts.check === 'function') {
-    const originalCheck = document.fonts.check.bind(document.fonts);
-    document.fonts.check = function(font, text) {
-      const family = String(font).match(/["']([^"']+)["']/)?.[1] || String(font).split(/s+/).at(-1);
-      if (family && profile.fonts.includes(family)) {
-        return true;
+  define(window.screen, 'colorDepth', 24);
+  define(window.screen, 'pixelDepth', 24);
+  define(Navigator.prototype, 'userAgentData', {
+    brands: profile.userAgentData.brands,
+    mobile: false,
+    platform: profile.userAgentData.platform,
+    toJSON: function() {
+      return {
+        brands: this.brands,
+        mobile: this.mobile,
+        platform: this.platform,
+      };
+    },
+    getHighEntropyValues: async function(hints) {
+      var source = {
+        architecture: profile.userAgentData.architecture,
+        bitness: profile.userAgentData.bitness,
+        brands: profile.userAgentData.brands,
+        fullVersionList: profile.userAgentData.fullVersionList,
+        mobile: false,
+        model: '',
+        platform: profile.userAgentData.platform,
+        platformVersion: profile.userAgentData.platformVersion,
+        uaFullVersion: profile.browserVersion,
+        wow64: false,
+      };
+      var values = {};
+      for (var i = 0; i < hints.length; i++) {
+        var hint = hints[i];
+        if (Object.prototype.hasOwnProperty.call(source, hint)) {
+          values[hint] = source[hint];
+        }
       }
-      return originalCheck(font, text);
+      return values;
+    },
+  });
+
+  if (typeof Intl !== 'undefined' && Intl.DateTimeFormat) {
+    var originalResolvedOptions = Intl.DateTimeFormat.prototype.resolvedOptions;
+    Intl.DateTimeFormat.prototype.resolvedOptions = function() {
+      var options = originalResolvedOptions.call(this);
+      options.timeZone = profile.timezoneId;
+      return options;
+    };
+  }
+
+  if (Date.prototype.getTimezoneOffset) {
+    var originalGetTimezoneOffset = Date.prototype.getTimezoneOffset;
+    var calculateTimezoneOffset = function(date) {
+      try {
+        var formatter = new Intl.DateTimeFormat('en-US', {
+          timeZone: profile.timezoneId,
+          hour12: false,
+          year: 'numeric',
+          month: '2-digit',
+          day: '2-digit',
+          hour: '2-digit',
+          minute: '2-digit',
+          second: '2-digit',
+        });
+        var parts = formatter.formatToParts(date);
+        var values = {};
+        for (var i = 0; i < parts.length; i++) {
+          if (parts[i].type !== 'literal') {
+            values[parts[i].type] = Number(parts[i].value);
+          }
+        }
+        var utcTime = Date.UTC(
+          values.year,
+          values.month - 1,
+          values.day,
+          values.hour,
+          values.minute,
+          values.second,
+        );
+        return Math.round((date.getTime() - utcTime) / 60000);
+      } catch {
+        return originalGetTimezoneOffset.call(date);
+      }
+    };
+    Date.prototype.getTimezoneOffset = function() {
+      return calculateTimezoneOffset(this);
     };
   }
-  const seedNoise = (seed, input) => {
-    const value = Math.sin(seed + input * 12.9898) * 43758.5453;
+
+  // --- CDP Runtime.enable leak defense ---
+  var _wrap = function(name) {
+    var orig = console[name];
+    if (typeof orig !== 'function') return;
+    console[name] = new Proxy(orig, {
+      apply: function(target, thisArg, args) {
+        for (var i = 0; i < args.length; i++) {
+          if (args[i] instanceof Error) {
+            var d = Object.getOwnPropertyDescriptor(args[i], 'stack');
+            if (d && typeof d.get === 'function') return undefined;
+          }
+        }
+        return Reflect.apply(target, thisArg, args);
+      },
+    });
+  };
+  ['debug', 'log', 'info', 'error', 'warn', 'trace', 'dir'].forEach(_wrap);
+
+  // --- Canvas fingerprint noise ---
+  var seedNoise = function(seed, input) {
+    var value = Math.sin(seed + input * 12.9898) * 43758.5453;
     return value - Math.floor(value);
   };
   if (HTMLCanvasElement.prototype.toDataURL) {
-    const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
-    HTMLCanvasElement.prototype.toDataURL = function(...args) {
-      const context = this.getContext('2d');
+    var originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
+    HTMLCanvasElement.prototype.toDataURL = function() {
+      var context = this.getContext('2d');
       if (context) {
-        const x = Math.min(1, Math.max(0, this.width - 1));
-        const y = Math.min(1, Math.max(0, this.height - 1));
-        const imageData = context.getImageData(x, y, 1, 1);
+        var x = Math.min(1, Math.max(0, this.width - 1));
+        var y = Math.min(1, Math.max(0, this.height - 1));
+        var imageData = context.getImageData(x, y, 1, 1);
         imageData.data[0] = Math.max(0, Math.min(255, imageData.data[0] + Math.floor(seedNoise(profile.canvasNoiseSeed, 1) * 2)));
         context.putImageData(imageData, x, y);
       }
-      return originalToDataURL.apply(this, args);
+      return originalToDataURL.apply(this, arguments);
     };
   }
+
+  // --- WebGL vendor/renderer spoofing ---
   if (typeof WebGLRenderingContext !== 'undefined') {
-    const originalGetParameter = WebGLRenderingContext.prototype.getParameter;
+    var originalGetParameter = WebGLRenderingContext.prototype.getParameter;
     WebGLRenderingContext.prototype.getParameter = function(parameter) {
       if (parameter === 37445) return profile.webglVendor;
       if (parameter === 37446) return profile.webglRenderer;
       return originalGetParameter.call(this, parameter);
     };
   }
+
+  // --- AudioBuffer fingerprint noise ---
   if (typeof AudioBuffer !== 'undefined' && typeof AnalyserNode !== 'undefined') {
-    const originalGetFloatFrequencyData = AnalyserNode.prototype.getFloatFrequencyData;
+    var originalGetFloatFrequencyData = AnalyserNode.prototype.getFloatFrequencyData;
     AnalyserNode.prototype.getFloatFrequencyData = function(array) {
       originalGetFloatFrequencyData.call(this, array);
-      for (let index = 0; index < array.length; index += 16) {
+      for (var index = 0; index < array.length; index += 16) {
         array[index] += (seedNoise(profile.audioNoiseSeed, index) - 0.5) * 0.0001;
       }
     };
   }
+
+  // --- Font availability spoofing ---
+  if (document.fonts && typeof document.fonts.check === 'function') {
+    var originalCheck = document.fonts.check.bind(document.fonts);
+    document.fonts.check = function(font, text) {
+      var family = String(font).match(/["']([^"']+)["']/)?.[1] || String(font).split(/\\s+/).at(-1);
+      if (family && profile.fonts.includes(family)) {
+        return true;
+      }
+      return originalCheck(font, text);
+    };
+  }
 })();`;
 }
+function buildUserAgentData(profile) {
+  const majorVersion = profile.browserVersion.split(".")[0] ?? "136";
+  const platformData = {
+    macos: { platform: "macOS", platformVersion: "14.4.0", architecture: "arm" },
+    windows: { platform: "Windows", platformVersion: "15.0.0", architecture: "x86" },
+    linux: { platform: "Linux", platformVersion: "6.5.0", architecture: "x86" }
+  };
+  const platformInfo = platformData[profile.platform];
+  return {
+    architecture: platformInfo.architecture,
+    bitness: "64",
+    brands: [
+      { brand: "Chromium", version: majorVersion },
+      ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: majorVersion }] : [{ brand: "Google Chrome", version: majorVersion }],
+      { brand: "Not-A.Brand", version: "99" }
+    ],
+    fullVersionList: [
+      { brand: "Chromium", version: profile.browserVersion },
+      ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: profile.browserVersion }] : [{ brand: "Google Chrome", version: profile.browserVersion }],
+      { brand: "Not-A.Brand", version: "99.0.0.0" }
+    ],
+    platform: platformInfo.platform,
+    platformVersion: platformInfo.platformVersion
+  };
+}
+function getPlatformString(platform) {
+  return platform === "macos" ? "MacIntel" : platform === "windows" ? "Win32" : "Linux x86_64";
+}
 
 // src/local-browser/stealth.ts
 var STEALTH_INIT_SCRIPT = `(() => {
@@ -12315,25 +12593,137 @@ var STEALTH_INIT_SCRIPT = `(() => {
   ['debug', 'log', 'info', 'error', 'warn', 'trace', 'dir'].forEach(_wrap);
 })();`;
 async function injectBrowserStealthScripts(context, input = {}) {
+  if (input.profile !== void 0) {
+    await installContextNetworkHeaders(context, input.profile);
+    await installCdpStealthOverrides(context, input.profile, input.page);
+  }
   if (typeof context.addInitScript === "function") {
     await context.addInitScript({
       content: input.profile === void 0 ? STEALTH_INIT_SCRIPT : generateStealthInitScript(input.profile)
     });
   }
 }
+function buildUserAgentMetadata(profile) {
+  const majorVersion = profile.browserVersion.split(".")[0] ?? "136";
+  const brands = [
+    { brand: "Chromium", version: majorVersion },
+    ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: majorVersion }] : [{ brand: "Google Chrome", version: majorVersion }],
+    { brand: "Not-A.Brand", version: "99" }
+  ];
+  const fullVersionList = [
+    { brand: "Chromium", version: profile.browserVersion },
+    ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: profile.browserVersion }] : [{ brand: "Google Chrome", version: profile.browserVersion }],
+    { brand: "Not-A.Brand", version: "99.0.0.0" }
+  ];
+  const platformMap = {
+    // Chromium keeps the reduced macOS UA token frozen to Intel even on Apple Silicon.
+    macos: { platform: "macOS", platformVersion: "14.4.0", architecture: "arm" },
+    windows: { platform: "Windows", platformVersion: "15.0.0", architecture: "x86" },
+    linux: { platform: "Linux", platformVersion: "6.5.0", architecture: "x86" }
+  };
+  const platformInfo = platformMap[profile.platform];
+  return {
+    brands,
+    fullVersionList,
+    platform: platformInfo.platform,
+    platformVersion: platformInfo.platformVersion,
+    architecture: platformInfo.architecture,
+    model: "",
+    mobile: false,
+    bitness: "64",
+    wow64: false
+  };
+}
+async function installCdpStealthOverrides(context, profile, initialPage) {
+  const pages = initialPage === void 0 ? context.pages() : Array.from(/* @__PURE__ */ new Set([initialPage, ...context.pages()]));
+  await Promise.all(pages.map((page) => applyPageOverrides(context, page, profile)));
+  const appliedPages = /* @__PURE__ */ new WeakSet();
+  const applyFuturePageOverrides = async (page) => {
+    if (appliedPages.has(page)) {
+      return;
+    }
+    appliedPages.add(page);
+    await applyPageOverrides(context, page, profile);
+  };
+  if (typeof context.on === "function") {
+    context.on("page", applyFuturePageOverrides);
+  }
+}
+async function installContextNetworkHeaders(context, profile) {
+  if (typeof context.setExtraHTTPHeaders !== "function") {
+    return;
+  }
+  await context.setExtraHTTPHeaders(buildStealthRequestHeaders(profile)).catch(() => void 0);
+}
+async function applyPageOverrides(context, page, profile) {
+  const contextWithCdp = context;
+  if (typeof contextWithCdp.newCDPSession !== "function") {
+    return;
+  }
+  let cdp;
+  try {
+    cdp = await contextWithCdp.newCDPSession(page);
+  } catch {
+    return;
+  }
+  try {
+    await applyCdpStealthCommands((method, params) => cdp.send(method, params), profile);
+  } catch {
+  } finally {
+    await cdp.detach().catch(() => void 0);
+  }
+}
+async function applyCdpStealthCommands(send, profile) {
+  await send("Network.setUserAgentOverride", {
+    userAgent: profile.userAgent,
+    acceptLanguage: `${profile.locale},en;q=0.9`,
+    platform: getPlatformString2(profile.platform),
+    userAgentMetadata: buildUserAgentMetadata(profile)
+  });
+  await send("Emulation.setDeviceMetricsOverride", {
+    width: profile.viewport.width,
+    height: profile.viewport.height,
+    deviceScaleFactor: profile.devicePixelRatio,
+    mobile: false,
+    screenWidth: profile.screenResolution.width,
+    screenHeight: profile.screenResolution.height
+  });
+  await send("Emulation.setLocaleOverride", {
+    locale: profile.locale
+  }).catch(() => void 0);
+  await send("Emulation.setTimezoneOverride", {
+    timezoneId: profile.timezoneId
+  }).catch(() => void 0);
+}
+function buildStealthRequestHeaders(profile) {
+  const metadata = buildUserAgentMetadata(profile);
+  return {
+    "Accept-Language": `${profile.locale},en;q=0.9`,
+    "Sec-CH-UA": metadata.brands.map(formatClientHintBrand).join(", "),
+    "Sec-CH-UA-Mobile": "?0",
+    "Sec-CH-UA-Platform": `"${metadata.platform}"`,
+    "User-Agent": profile.userAgent
+  };
+}
+function formatClientHintBrand(brand2) {
+  return `"${brand2.brand}";v="${brand2.version}"`;
+}
+function getPlatformString2(platform) {
+  return platform === "macos" ? "MacIntel" : platform === "windows" ? "Win32" : "Linux x86_64";
+}
 
 // src/local-browser/stealth-profiles.ts
 var PROFILE_PRESETS = [
   {
     platform: "macos",
     browserBrand: "chrome",
-    browserVersion: "133.0.6943.99",
-    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.6943.99 Safari/537.36",
+    browserVersion: "136.0.7103.93",
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
     viewport: { width: 1440, height: 900 },
     screenResolution: { width: 1512, height: 982 },
     devicePixelRatio: 2,
     maxTouchPoints: 0,
-    webglVendor: "Apple Inc.",
+    webglVendor: "Apple",
     webglRenderer: "Apple M2",
     fonts: ["SF Pro Text", "Helvetica Neue", "Arial", "Menlo", "Apple Color Emoji"],
     locale: "en-US",
@@ -12342,8 +12732,8 @@ var PROFILE_PRESETS = [
   {
     platform: "windows",
     browserBrand: "chrome",
-    browserVersion: "133.0.6943.99",
-    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.6943.99 Safari/537.36",
+    browserVersion: "136.0.7103.93",
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
     viewport: { width: 1536, height: 864 },
     screenResolution: { width: 1920, height: 1080 },
     devicePixelRatio: 1.25,
@@ -12357,8 +12747,8 @@ var PROFILE_PRESETS = [
   {
     platform: "windows",
     browserBrand: "edge",
-    browserVersion: "133.0.3065.82",
-    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.3065.82",
+    browserVersion: "136.0.3240.50",
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.3240.50",
     viewport: { width: 1536, height: 864 },
     screenResolution: { width: 1920, height: 1080 },
     devicePixelRatio: 1.25,
@@ -12372,8 +12762,8 @@ var PROFILE_PRESETS = [
   {
     platform: "linux",
     browserBrand: "chrome",
-    browserVersion: "133.0.6943.99",
-    userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.6943.99 Safari/537.36",
+    browserVersion: "136.0.7103.93",
+    userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
     viewport: { width: 1366, height: 768 },
     screenResolution: { width: 1366, height: 768 },
     devicePixelRatio: 1,
@@ -12413,8 +12803,115 @@ function pickStealthProfilePreset(overrides) {
   const pool = candidates.length > 0 ? candidates : PROFILE_PRESETS;
   return pool[Math.floor(Math.random() * pool.length)];
 }
+var OPENSTEER_LIVE_SESSION_LAYOUT = "opensteer-session";
+var OPENSTEER_LIVE_SESSION_VERSION = 1;
+var LEGACY_CLOUD_SESSION_LAYOUT = "opensteer-cloud-session";
+var LEGACY_CLOUD_SESSION_VERSION = 1;
+function resolveLiveSessionRecordPath(rootPath) {
+  return path6__default.default.join(rootPath, "live", "session.json");
+}
+function resolveLegacyLiveBrowserRecordPath(rootPath) {
+  return path6__default.default.join(rootPath, "live", "browser.json");
+}
+function resolveLegacyCloudSessionRecordPath(rootPath) {
+  return path6__default.default.join(rootPath, "live", "cloud-session.json");
+}
+async function readPersistedSessionRecord(rootPath) {
+  const sessionPath = resolveLiveSessionRecordPath(rootPath);
+  if (await pathExists(sessionPath)) {
+    const parsed = await readJsonFile(sessionPath);
+    if (isPersistedLocalBrowserSessionRecord(parsed)) {
+      return parsed;
+    }
+    if (isPersistedCloudSessionRecord(parsed)) {
+      return parsed;
+    }
+  }
+  const legacyCloudPath = resolveLegacyCloudSessionRecordPath(rootPath);
+  if (await pathExists(legacyCloudPath)) {
+    const parsed = await readJsonFile(legacyCloudPath);
+    if (isLegacyCloudSessionRecord(parsed)) {
+      return {
+        layout: OPENSTEER_LIVE_SESSION_LAYOUT,
+        version: OPENSTEER_LIVE_SESSION_VERSION,
+        provider: "cloud",
+        mode: "cloud",
+        ...parsed.workspace === void 0 ? {} : { workspace: parsed.workspace },
+        sessionId: parsed.sessionId,
+        baseUrl: parsed.baseUrl,
+        startedAt: parsed.startedAt,
+        updatedAt: parsed.updatedAt
+      };
+    }
+  }
+  const legacyBrowserPath = resolveLegacyLiveBrowserRecordPath(rootPath);
+  if (await pathExists(legacyBrowserPath)) {
+    const parsed = await readJsonFile(legacyBrowserPath);
+    if (isLegacyLocalBrowserSessionRecord(parsed)) {
+      return {
+        layout: OPENSTEER_LIVE_SESSION_LAYOUT,
+        version: OPENSTEER_LIVE_SESSION_VERSION,
+        provider: "local",
+        mode: "browser",
+        engine: parsed.engine ?? "playwright",
+        ...parsed.endpoint === void 0 ? {} : { endpoint: parsed.endpoint },
+        ...parsed.baseUrl === void 0 ? {} : { baseUrl: parsed.baseUrl },
+        ...parsed.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: parsed.remoteDebuggingUrl },
+        ...parsed.sessionDir === void 0 ? {} : { sessionDir: parsed.sessionDir },
+        pid: parsed.pid,
+        startedAt: parsed.startedAt,
+        updatedAt: parsed.startedAt,
+        ...parsed.executablePath === void 0 ? {} : { executablePath: parsed.executablePath },
+        userDataDir: parsed.userDataDir
+      };
+    }
+  }
+  return void 0;
+}
+async function readPersistedCloudSessionRecord(rootPath) {
+  const record = await readPersistedSessionRecord(rootPath);
+  return record?.provider === "cloud" ? record : void 0;
+}
+async function readPersistedLocalBrowserSessionRecord(rootPath) {
+  const record = await readPersistedSessionRecord(rootPath);
+  return record?.provider === "local" ? record : void 0;
+}
+async function hasPersistedCloudSession(rootPath) {
+  return await readPersistedCloudSessionRecord(rootPath) !== void 0;
+}
+async function writePersistedSessionRecord(rootPath, record) {
+  await writeJsonFileAtomic(resolveLiveSessionRecordPath(rootPath), record);
+  await clearLegacySessionRecordPaths(rootPath);
+}
+async function clearPersistedSessionRecord(rootPath) {
+  await Promise.all([
+    removeIfPresent(resolveLiveSessionRecordPath(rootPath)),
+    clearLegacySessionRecordPaths(rootPath)
+  ]);
+}
+function isPersistedCloudSessionRecord(value) {
+  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "cloud" && value.mode === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.baseUrl === "string" && value.baseUrl.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.mode === "browser" && (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 isLegacyCloudSessionRecord(value) {
+  return value.layout === LEGACY_CLOUD_SESSION_LAYOUT && value.version === LEGACY_CLOUD_SESSION_VERSION && value.mode === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.baseUrl === "string" && value.baseUrl.length > 0 && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+}
+function isLegacyLocalBrowserSessionRecord(value) {
+  return value.mode === "persistent" && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.userDataDir === "string" && value.userDataDir.length > 0;
+}
+async function clearLegacySessionRecordPaths(rootPath) {
+  await Promise.all([
+    removeIfPresent(resolveLegacyLiveBrowserRecordPath(rootPath)),
+    removeIfPresent(resolveLegacyCloudSessionRecordPath(rootPath))
+  ]);
+}
+async function removeIfPresent(filePath) {
+  await promises.rm(filePath, { force: true }).catch(() => void 0);
+}
 
-// src/internal/engine-selection.ts
+// ../runtime-core/src/internal/engine-selection.ts
 var OPENSTEER_ENGINE_NAMES = ["playwright", "abp"];
 var DEFAULT_OPENSTEER_ENGINE = "playwright";
 function resolveOpensteerEngineName(input = {}) {
@@ -12617,7 +13114,7 @@ var OpensteerBrowserManager = class {
       await this.closePersistentBrowser(workspace);
       await promises.rm(resolveAbpSessionDir(workspace), { recursive: true, force: true });
       await promises.rm(workspace.browserPath, { recursive: true, force: true });
-      await promises.rm(workspace.liveBrowserPath, { force: true });
+      await clearPersistedSessionRecord(workspace.rootPath);
       await ensureDirectory(workspace.browserUserDataDir);
     });
   }
@@ -12628,7 +13125,7 @@ var OpensteerBrowserManager = class {
       await this.closePersistentBrowser(workspace);
       await promises.rm(resolveAbpSessionDir(workspace), { recursive: true, force: true });
       await promises.rm(workspace.browserPath, { recursive: true, force: true });
-      await promises.rm(workspace.liveBrowserPath, { force: true });
+      await clearPersistedSessionRecord(workspace.rootPath);
     });
   }
   async close() {
@@ -12706,12 +13203,12 @@ var OpensteerBrowserManager = class {
         sessionDir: resolveAbpSessionDir(workspace),
         ...launch?.browserExecutablePath === void 0 ? {} : { executablePath: launch.browserExecutablePath }
       };
-      await writeJsonFileAtomic(workspace.liveBrowserPath, liveRecord);
+      await this.writeLivePersistentBrowser(workspace, liveRecord);
       try {
         return await this.createAdoptedAbpEngine(liveRecord);
       } catch (error) {
         await terminateProcess(launched.process.pid ?? 0).catch(() => void 0);
-        await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+        await clearPersistedSessionRecord(workspace.rootPath).catch(() => void 0);
         throw error;
       }
     });
@@ -12733,7 +13230,8 @@ var OpensteerBrowserManager = class {
     await clearChromeSingletonEntries(userDataDir);
     const launched = await launchOwnedBrowser({
       userDataDir,
-      ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions }
+      ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
+      ...this.contextOptions?.viewport === void 0 ? {} : { viewport: this.contextOptions.viewport }
     });
     try {
       return await this.createAttachedEngine({
@@ -12781,7 +13279,8 @@ var OpensteerBrowserManager = class {
       await this.ensurePersistentBrowserManifest(workspace);
       const launched = await launchOwnedBrowser({
         userDataDir: workspace.browserUserDataDir,
-        ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions }
+        ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
+        ...this.contextOptions?.viewport === void 0 ? {} : { viewport: this.contextOptions.viewport }
       });
       const liveRecord = {
         mode: "persistent",
@@ -12792,7 +13291,7 @@ var OpensteerBrowserManager = class {
         executablePath: launched.executablePath,
         userDataDir: workspace.browserUserDataDir
       };
-      await writeJsonFileAtomic(workspace.liveBrowserPath, liveRecord);
+      await this.writeLivePersistentBrowser(workspace, liveRecord);
       try {
         return await this.createAttachedEngine({
           endpoint: launched.endpoint,
@@ -12801,7 +13300,7 @@ var OpensteerBrowserManager = class {
         });
       } catch (error) {
         await terminateProcess(launched.pid).catch(() => void 0);
-        await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+        await clearPersistedSessionRecord(workspace.rootPath).catch(() => void 0);
         throw error;
       }
     });
@@ -12816,13 +13315,16 @@ var OpensteerBrowserManager = class {
       if (!context) {
         throw new Error("Connected browser did not expose a Chromium browser context.");
       }
+      const page = input.freshTab || context.pages()[0] === void 0 ? await context.newPage() : context.pages()[0];
+      await page.bringToFront?.();
       const stealthProfile = resolveStealthProfile(this.contextOptions?.stealthProfile);
       await injectBrowserStealthScripts(
         context,
-        stealthProfile === void 0 ? {} : { profile: stealthProfile }
+        stealthProfile === void 0 ? {} : {
+          profile: stealthProfile,
+          page
+        }
       );
-      const page = input.freshTab || context.pages()[0] === void 0 ? await context.newPage() : context.pages()[0];
-      await page.bringToFront?.();
       const engine = await enginePlaywright.createPlaywrightBrowserCoreEngine({
         browser,
         attachedContext: context,
@@ -12904,7 +13406,7 @@ var OpensteerBrowserManager = class {
       return void 0;
     }
     if (!isProcessRunning(live.pid)) {
-      await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+      await clearPersistedSessionRecord(workspace.rootPath).catch(() => void 0);
       return void 0;
     }
     if (live.engine === "playwright") {
@@ -12923,19 +13425,8 @@ var OpensteerBrowserManager = class {
     return live;
   }
   async readStoredLiveBrowser(workspace) {
-    if (!await pathExists(workspace.liveBrowserPath)) {
-      return void 0;
-    }
-    const live = await readJsonFile(
-      workspace.liveBrowserPath
-    );
-    if (live.engine === "abp") {
-      return live;
-    }
-    return {
-      ...live,
-      engine: "playwright"
-    };
+    const live = await readPersistedLocalBrowserSessionRecord(workspace.rootPath);
+    return live === void 0 ? void 0 : toWorkspaceLiveBrowserRecord(live);
   }
   async resolveLivePersistentEngineName() {
     if (this.mode !== "persistent") {
@@ -12955,7 +13446,7 @@ var OpensteerBrowserManager = class {
   async closePersistentBrowser(workspace) {
     const live = await this.readStoredLiveBrowser(workspace);
     if (!live) {
-      await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+      await clearPersistedSessionRecord(workspace.rootPath).catch(() => void 0);
       return;
     }
     if (live.engine === "playwright") {
@@ -12963,15 +13454,21 @@ var OpensteerBrowserManager = class {
         await requestBrowserClose(live.endpoint).catch(() => void 0);
       }
       if (await waitForProcessExit(live.pid, BROWSER_CLOSE_TIMEOUT_MS)) {
-        await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+        await clearPersistedSessionRecord(workspace.rootPath).catch(() => void 0);
         return;
       }
       await terminateProcess(live.pid).catch(() => void 0);
-      await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+      await clearPersistedSessionRecord(workspace.rootPath).catch(() => void 0);
       return;
     }
     await terminateProcess(live.pid).catch(() => void 0);
-    await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+    await clearPersistedSessionRecord(workspace.rootPath).catch(() => void 0);
+  }
+  async writeLivePersistentBrowser(workspace, live) {
+    await writePersistedSessionRecord(
+      workspace.rootPath,
+      toPersistedLocalBrowserSessionRecord(this.workspace, live)
+    );
   }
   requirePersistentMode(method) {
     if (this.mode !== "persistent" || this.workspace === void 0) {
@@ -12983,6 +13480,39 @@ function normalizeWorkspace(workspace) {
   const normalized = workspace?.trim();
   return normalized === void 0 || normalized.length === 0 ? void 0 : normalized;
 }
+function toPersistedLocalBrowserSessionRecord(workspace, live) {
+  return {
+    layout: "opensteer-session",
+    version: 1,
+    provider: "local",
+    mode: "browser",
+    ...workspace === void 0 ? {} : { workspace },
+    engine: live.engine,
+    ...live.endpoint === void 0 ? {} : { endpoint: live.endpoint },
+    ...live.baseUrl === void 0 ? {} : { baseUrl: live.baseUrl },
+    ...live.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: live.remoteDebuggingUrl },
+    ...live.sessionDir === void 0 ? {} : { sessionDir: live.sessionDir },
+    pid: live.pid,
+    startedAt: live.startedAt,
+    updatedAt: Date.now(),
+    ...live.executablePath === void 0 ? {} : { executablePath: live.executablePath },
+    userDataDir: live.userDataDir
+  };
+}
+function toWorkspaceLiveBrowserRecord(record) {
+  return {
+    mode: "persistent",
+    engine: record.engine,
+    ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
+    ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
+    ...record.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: record.remoteDebuggingUrl },
+    ...record.sessionDir === void 0 ? {} : { sessionDir: record.sessionDir },
+    pid: record.pid,
+    startedAt: record.startedAt,
+    ...record.executablePath === void 0 ? {} : { executablePath: record.executablePath },
+    userDataDir: record.userDataDir
+  };
+}
 function resolveBrowserMode(workspace, browser) {
   if (browser === void 0) {
     return workspace === void 0 ? "temporary" : "persistent";
@@ -13008,8 +13538,9 @@ async function resolveAttachEndpoint(browser) {
 async function launchOwnedBrowser(input) {
   await ensureDirectory(input.userDataDir);
   await clearChromeSingletonEntries(input.userDataDir);
+  await sanitizeChromeProfile(input.userDataDir);
   const executablePath = resolveChromeExecutablePath(input.launch?.executablePath);
-  const args = buildChromeArgs(input.userDataDir, input.launch);
+  const args = buildChromeArgs(input.userDataDir, input.launch, input.viewport);
   const child = child_process.spawn(executablePath, args, {
     stdio: ["ignore", "ignore", "pipe"],
     detached: process.platform !== "win32"
@@ -13036,7 +13567,8 @@ async function launchOwnedBrowser(input) {
     executablePath
   };
 }
-function buildChromeArgs(userDataDir, launch) {
+function buildChromeArgs(userDataDir, launch, viewport) {
+  const isHeadless = launch?.headless ?? true;
   const args = [
     "--remote-debugging-port=0",
     "--no-first-run",
@@ -13050,17 +13582,23 @@ function buildChromeArgs(userDataDir, launch) {
     "--disable-popup-blocking",
     "--disable-prompt-on-repost",
     "--disable-sync",
+    "--disable-infobars",
     "--disable-features=Translate",
     "--enable-features=NetworkService,NetworkServiceInProcess",
     "--password-store=basic",
     "--use-mock-keychain",
     `--user-data-dir=${userDataDir}`
   ];
-  if (launch?.headless ?? true) {
+  if (isHeadless) {
     args.push("--headless=new");
-    if (!(launch?.args ?? []).some((entry) => entry.startsWith("--window-size"))) {
-      args.push("--window-size=1280,800");
-    }
+  }
+  const hasUserWindowSize = (launch?.args ?? []).some((entry) => entry.startsWith("--window-size"));
+  if (!hasUserWindowSize) {
+    const width = viewport?.width ?? 1440;
+    const height = viewport?.height ?? 900;
+    args.push(
+      isHeadless ? `--window-size=${String(width)},${String(height)}` : `--window-size=${String(width)},${String(height + 150)}`
+    );
   }
   args.push(...launch?.args ?? []);
   return args;
@@ -13252,7 +13790,14 @@ async function sleep(ms) {
   await new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
-// src/internal/errors.ts
+// ../runtime-core/package.json
+var package_default = {
+  version: "0.1.0"};
+
+// ../runtime-core/src/version.ts
+var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
+
+// ../runtime-core/src/internal/errors.ts
 function normalizeThrownOpensteerError(error, fallbackMessage) {
   if (isOpensteerProtocolError(error)) {
     return toOpensteerError(error);
@@ -13263,15 +13808,6 @@ function normalizeThrownOpensteerError(error, fallbackMessage) {
       ...error.details === void 0 ? {} : { details: error.details }
     });
   }
-  if (error instanceof OpensteerAttachAmbiguousError) {
-    return createOpensteerError("conflict", error.message, {
-      details: {
-        candidates: error.candidates,
-        code: error.code,
-        name: error.name
-      }
-    });
-  }
   if (error instanceof Error) {
     return createOpensteerError("operation-failed", error.message, {
       details: {
@@ -13441,7 +13977,7 @@ function roundScale(value) {
   return Number(value.toFixed(6));
 }
 
-// src/runtimes/computer-use/trace-enrichment.ts
+// ../runtime-core/src/runtimes/computer-use/trace-enrichment.ts
 async function enrichComputerUseTrace(input) {
   const tracePoints = toTracePoints(input.action);
   if (tracePoints.length === 0) {
@@ -13534,7 +14070,7 @@ function toOpensteerResolvedTarget(target) {
   };
 }
 
-// src/runtimes/computer-use/runtime.ts
+// ../runtime-core/src/runtimes/computer-use/runtime.ts
 function createComputerUseRuntime(options) {
   return new DefaultComputerUseRuntime(options);
 }
@@ -13629,7 +14165,7 @@ function normalizeScreenshotOptions(input) {
   };
 }
 
-// src/sdk/semantic-dispatch.ts
+// ../runtime-core/src/sdk/semantic-dispatch.ts
 async function dispatchSemanticOperation(runtime, operation, input, options = {}) {
   switch (operation) {
     case "session.open":
@@ -13890,7 +14426,7 @@ async function dispatchSemanticOperation(runtime, operation, input, options = {}
   }
 }
 
-// src/requests/shared.ts
+// ../runtime-core/src/requests/shared.ts
 var REDACTED_HEADER_VALUE = "[redacted]";
 var HTTP_HEADER_NAME_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
 var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
@@ -14106,14 +14642,14 @@ function resolveTextEncoding(charset) {
   }
 }
 
-// src/requests/errors.ts
+// ../runtime-core/src/requests/errors.ts
 function invalidRequestPlanError(message, details = {}) {
   return new OpensteerProtocolError("invalid-request", message, {
     details
   });
 }
 
-// src/requests/plans/index.ts
+// ../runtime-core/src/requests/plans/index.ts
 var HTTP_METHOD_PATTERN = /^[A-Za-z]+$/;
 var URL_TEMPLATE_PLACEHOLDER_PATTERN = /\{([A-Za-z][A-Za-z0-9_-]*)\}/g;
 function assertValidRequestPlanPayload(payload) {
@@ -14521,7 +15057,7 @@ function normalizeTrimmedString(field, value) {
   return normalized;
 }
 
-// src/requests/inference.ts
+// ../runtime-core/src/requests/inference.ts
 function inferRequestPlanFromNetworkRecord(record, input, options = {}) {
   const url = new URL(record.record.url);
   const defaultQuery = Array.from(url.searchParams.entries()).map(
@@ -14534,6 +15070,7 @@ function inferRequestPlanFromNetworkRecord(record, input, options = {}) {
   const responseContentType = headerValue(record.record.responseHeaders, "content-type") ?? record.record.responseBody?.mimeType;
   const defaultHeaders = inferDefaultHeaders(record);
   const auth = inferAuth(record.record.requestHeaders);
+  const body = inferRequestPlanBody(record.record.requestBody, requestContentType);
   const payload = normalizeRequestPlanPayload({
     transport: {
       kind: "context-http"
@@ -14544,12 +15081,7 @@ function inferRequestPlanFromNetworkRecord(record, input, options = {}) {
       ...defaultQuery.length === 0 ? {} : { defaultQuery },
       ...defaultHeaders.length === 0 ? {} : { defaultHeaders }
     },
-    ...requestContentType === void 0 && record.record.requestBody === void 0 ? {} : {
-      body: {
-        ...requestContentType === void 0 ? {} : { contentType: requestContentType },
-        required: true
-      }
-    },
+    ...body === void 0 ? {} : { body },
     ...record.record.status === void 0 ? {} : {
       response: {
         status: record.record.status,
@@ -14605,22 +15137,66 @@ function inferAuth(headers) {
   }
   return void 0;
 }
-
-// src/reverse/materialization.ts
-var ALWAYS_OMIT_HEADER_NAMES = /* @__PURE__ */ new Set(["content-length", "host", "priority"]);
-var BROWSER_OWNED_HEADER_PREFIXES = ["sec-"];
-function isManagedRequestHeaderName(name, transport) {
-  const normalized = normalizeHeaderName(name);
-  if (!isValidHttpHeaderName(name)) {
-    return true;
-  }
-  if (normalized.startsWith(":")) {
-    return true;
-  }
-  if (ALWAYS_OMIT_HEADER_NAMES.has(normalized)) {
-    return true;
+function inferRequestPlanBody(body, contentType) {
+  if (body === void 0) {
+    return void 0;
   }
-  if (transport !== void 0 && (transport === "page-http" || transport === "session-http")) {
+  const text = Buffer.from(body.data, "base64").toString("utf8");
+  const normalizedContentType = contentType?.toLowerCase();
+  const trimmedText = text.trim();
+  const parsedJson = parseJsonBody(trimmedText);
+  if (normalizedContentType?.includes("application/json") === true || normalizedContentType?.includes("+json") === true || parsedJson !== void 0) {
+    return {
+      kind: "json",
+      required: true,
+      ...contentType === void 0 ? {} : { contentType },
+      template: parsedJson ?? text
+    };
+  }
+  if (normalizedContentType?.includes("application/x-www-form-urlencoded") === true) {
+    return {
+      kind: "form",
+      required: true,
+      ...contentType === void 0 ? {} : { contentType },
+      fields: Array.from(new URLSearchParams(text).entries()).map(([name, value]) => ({
+        name,
+        value
+      }))
+    };
+  }
+  return {
+    kind: "text",
+    required: true,
+    ...contentType === void 0 ? {} : { contentType },
+    template: text
+  };
+}
+function parseJsonBody(value) {
+  if (value.length === 0 || !value.startsWith("{") && !value.startsWith("[")) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+
+// ../runtime-core/src/reverse/materialization.ts
+var ALWAYS_OMIT_HEADER_NAMES = /* @__PURE__ */ new Set(["content-length", "host", "priority"]);
+var BROWSER_OWNED_HEADER_PREFIXES = ["sec-"];
+function isManagedRequestHeaderName(name, transport) {
+  const normalized = normalizeHeaderName(name);
+  if (!isValidHttpHeaderName(name)) {
+    return true;
+  }
+  if (normalized.startsWith(":")) {
+    return true;
+  }
+  if (ALWAYS_OMIT_HEADER_NAMES.has(normalized)) {
+    return true;
+  }
+  if (transport !== void 0 && (transport === "page-http" || transport === "session-http")) {
     if (BROWSER_OWNED_HEADER_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
       return true;
     }
@@ -14642,7 +15218,7 @@ function finalizeMaterializedTransportRequest(request, transport) {
   };
 }
 
-// src/network/diff.ts
+// ../runtime-core/src/network/diff.ts
 function diffNetworkRecords(left, right, input) {
   const requestDiffs = [];
   const responseDiffs = [];
@@ -14802,7 +15378,7 @@ function diffStringMap(prefix, left, right, includeUnchanged, output) {
     diffScalarField(`${prefix}.${key}`, left[key], right[key], includeUnchanged, output);
   }
 }
-function diffScalarField(path11, left, right, includeUnchanged, output) {
+function diffScalarField(path13, left, right, includeUnchanged, output) {
   const leftValue = stringifyFieldValue(left);
   const rightValue = stringifyFieldValue(right);
   const kind = leftValue === void 0 ? rightValue === void 0 ? "unchanged" : "added" : rightValue === void 0 ? "removed" : leftValue === rightValue ? "unchanged" : "changed";
@@ -14810,7 +15386,7 @@ function diffScalarField(path11, left, right, includeUnchanged, output) {
     return;
   }
   output.push({
-    path: path11,
+    path: path13,
     kind,
     ...leftValue === void 0 ? {} : { leftValue },
     ...rightValue === void 0 ? {} : { rightValue },
@@ -14999,7 +15575,7 @@ var NetworkJournal = class {
   }
 };
 
-// src/network/minimize.ts
+// ../runtime-core/src/network/minimize.ts
 function prepareMinimizationRequest(record, preserve = []) {
   const requestUrl = new URL(record.record.url);
   const preservedNames = new Set(
@@ -15412,7 +15988,7 @@ function resolveBodyEncoding2(charset) {
   }
 }
 
-// src/network/probe.ts
+// ../runtime-core/src/network/probe.ts
 var TRANSPORT_PROBE_LADDER = [
   "direct-http",
   "matched-tls",
@@ -15424,7 +16000,7 @@ function selectTransportProbeRecommendation(results) {
   return results.find((entry) => entry.success)?.transport ?? results.at(-1)?.transport ?? "session-http";
 }
 
-// src/reverse/analysis.ts
+// ../runtime-core/src/reverse/analysis.ts
 var TELEMETRY_HOST_PATTERNS = [
   "google-analytics",
   "doubleclick",
@@ -15764,9 +16340,9 @@ function matchReverseTargetHints(channel, codec, targetHints) {
       matches.add(`host:${host}`);
     }
   }
-  for (const path11 of targetHints.paths ?? []) {
-    if (url.pathname.includes(path11)) {
-      matches.add(`path:${path11}`);
+  for (const path13 of targetHints.paths ?? []) {
+    if (url.pathname.includes(path13)) {
+      matches.add(`path:${path13}`);
     }
   }
   for (const operationName of targetHints.operationNames ?? []) {
@@ -16618,7 +17194,7 @@ function looksHighEntropy(value) {
   return uniqueCharacters >= Math.min(20, Math.floor(trimmed.length * 0.6));
 }
 
-// src/reverse/discovery.ts
+// ../runtime-core/src/reverse/discovery.ts
 function clusterReverseObservationRecords(input) {
   const groups = /* @__PURE__ */ new Map();
   for (const item of sortClusterableRecords(input.records)) {
@@ -16918,14 +17494,14 @@ async function isExecutable(candidate) {
 }
 async function readDirSafe(directory) {
   try {
-    const { readdir: readdir3 } = await import('fs/promises');
-    return await readdir3(directory);
+    const { readdir: readdir4 } = await import('fs/promises');
+    return await readdir4(directory);
   } catch {
     return [];
   }
 }
 
-// src/reverse/validation.ts
+// ../runtime-core/src/reverse/validation.ts
 function buildReverseValidationRules(input) {
   switch (input.channel.kind) {
     case "http":
@@ -17202,7 +17778,7 @@ function jsonStructureShape(value) {
   return typeof value;
 }
 
-// src/reverse/workflows.ts
+// ../runtime-core/src/reverse/workflows.ts
 function buildReversePackageWorkflow(input) {
   if (input.template === void 0 && input.executeStepInput === void 0) {
     return [];
@@ -17571,7 +18147,7 @@ function dedupeSuggestedEdits(suggestions) {
   return [...new Map(suggestions.map((suggestion) => [suggestion.id, suggestion])).values()];
 }
 
-// src/sdk/extraction-data-path.ts
+// ../runtime-core/src/sdk/extraction-data-path.ts
 function joinDataPath(base, key) {
   const normalizedBase = base.trim();
   const normalizedKey = key.trim();
@@ -17602,8 +18178,8 @@ function encodeDataPath(tokens) {
   }
   return out;
 }
-function parseDataPath(path11) {
-  const input = path11.trim();
+function parseDataPath(path13) {
+  const input = path13.trim();
   if (input.length === 0) {
     return [];
   }
@@ -17653,8 +18229,8 @@ function parseDataPath(path11) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path11, value] of Object.entries(flat)) {
-    const tokens = parseDataPath(path11);
+  for (const [path13, value] of Object.entries(flat)) {
+    const tokens = parseDataPath(path13);
     if (!tokens || tokens.length === 0) {
       continue;
     }
@@ -17712,7 +18288,7 @@ function assignDataPathValue(root, tokens, value) {
   }
 }
 
-// src/sdk/extraction-consolidation.ts
+// ../runtime-core/src/sdk/extraction-consolidation.ts
 var STRUCTURAL_ATTR_KEYS = /* @__PURE__ */ new Set([
   "class",
   "role",
@@ -17986,8 +18562,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path11, mode) {
-  const normalized = sanitizeElementPath(path11);
+function minimizePathMatchClauses(path13, mode) {
+  const normalized = sanitizeElementPath(path13);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -18091,8 +18667,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path11, mode) {
-  const normalized = sanitizeElementPath(path11);
+function relaxPathForSingleSample(path13, mode) {
+  const normalized = sanitizeElementPath(path13);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -18177,8 +18753,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path11) {
-  const normalized = sanitizeElementPath(path11);
+function buildPathStructureKey(path13) {
+  const normalized = sanitizeElementPath(path13);
   return canonicalJsonString({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -18305,30 +18881,30 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path11, node) {
-  const tokens = parseDataPath(path11);
+function insertNodeAtPath(root, path13, node) {
+  const tokens = parseDataPath(path13);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path11}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path13}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path11}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path13}": 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 "${path11}": expected object segment.`);
+      throw new Error(`Invalid persisted extraction path "${path13}": 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 "${path11}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path13}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -18343,7 +18919,7 @@ function insertNodeAtPath(root, path11, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path11}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path13}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -18378,7 +18954,7 @@ function buildItemRootForArrayIndex(entries) {
   }
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path11) => path11 !== null);
+  ).filter((path13) => path13 !== null);
   if (!paths.length) {
     return null;
   }
@@ -18399,7 +18975,7 @@ function getCommonPathPrefixLength(paths) {
   if (!paths.length) {
     return 0;
   }
-  const nodeChains = paths.map((path11) => path11.nodes);
+  const nodeChains = paths.map((path13) => path13.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) {
     return 0;
@@ -18468,30 +19044,30 @@ function mergeElementPathsByMajority(paths) {
   if (!paths.length) {
     return null;
   }
-  const normalized = paths.map((path11) => sanitizeElementPath(path11));
+  const normalized = paths.map((path13) => sanitizeElementPath(path13));
   const contextKey = pickModeString(
-    normalized.map((path11) => canonicalJsonString(path11.context)),
+    normalized.map((path13) => canonicalJsonString(path13.context)),
     1
   );
   if (!contextKey) {
     return null;
   }
-  const sameContext = normalized.filter((path11) => canonicalJsonString(path11.context) === contextKey);
+  const sameContext = normalized.filter((path13) => canonicalJsonString(path13.context) === contextKey);
   if (!sameContext.length) {
     return null;
   }
   const targetLength = pickModeNumber(
-    sameContext.map((path11) => path11.nodes.length),
+    sameContext.map((path13) => path13.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
-  const aligned = sameContext.filter((path11) => path11.nodes.length === targetLength);
+  const aligned = sameContext.filter((path13) => path13.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((path11) => path11.nodes[index]).filter((node) => node !== void 0);
+    const nodesAtIndex = aligned.map((path13) => path13.nodes[index]).filter((node) => node !== void 0);
     if (!nodesAtIndex.length) {
       return null;
     }
@@ -18737,8 +19313,8 @@ function clonePathContext(context) {
 function clonePathNodes(nodes) {
   return JSON.parse(JSON.stringify(nodes || []));
 }
-function cloneElementPath2(path11) {
-  return JSON.parse(JSON.stringify(path11));
+function cloneElementPath2(path13) {
+  return JSON.parse(JSON.stringify(path13));
 }
 function clonePersistedOpensteerExtractionNode(node) {
   return JSON.parse(JSON.stringify(node));
@@ -18759,7 +19335,7 @@ function isPersistedObjectNode(node) {
   return !!node && typeof node === "object" && !Array.isArray(node) && !isPersistedOpensteerExtractionValueNode(node) && !isPersistedOpensteerExtractionSourceNode(node) && !isPersistedOpensteerExtractionArrayNode(node);
 }
 
-// src/sdk/extraction.ts
+// ../runtime-core/src/sdk/extraction.ts
 function assertValidOpensteerExtractionSchemaRoot(schema) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     throw new Error("Invalid extraction schema: expected a JSON object at the top level.");
@@ -19024,12 +19600,12 @@ async function resolvePersistableFieldTargets(options) {
         anchor: field.anchor
       }
     });
-    const path11 = resolved.replayPath ?? await options.dom.buildPath({
+    const path13 = resolved.replayPath ?? await options.dom.buildPath({
       locator: resolved.locator
     });
     fields.push({
       key: field.key,
-      path: sanitizeElementPath(path11),
+      path: sanitizeElementPath(path13),
       ...field.attribute === void 0 ? {} : { attribute: field.attribute }
     });
   }
@@ -19112,8 +19688,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path11) => {
-          node.$path = sanitizeElementPath(path11);
+        replacePath: (path13) => {
+          node.$path = sanitizeElementPath(path13);
         }
       }
     ];
@@ -19127,13 +19703,13 @@ function collectPersistedValueNodeRefs(node) {
   }
   return refs;
 }
-function hasPositionClause(path11) {
-  return path11.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
+function hasPositionClause(path13) {
+  return path13.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
 }
-function stripPositionClauses2(path11) {
+function stripPositionClauses2(path13) {
   return sanitizeElementPath({
-    context: path11.context,
-    nodes: path11.nodes.map((node) => ({
+    context: path13.context,
+    nodes: path13.nodes.map((node) => ({
       ...node,
       match: node.match.filter((clause) => clause.kind !== "position")
     }))
@@ -19543,14 +20119,14 @@ function normalizeNonEmptyString2(name, value) {
 function normalizeKey(value) {
   return String(value ?? "").trim();
 }
-function labelForPath(path11) {
-  return path11.trim().length === 0 ? "$" : path11;
+function labelForPath(path13) {
+  return path13.trim().length === 0 ? "$" : path13;
 }
 function sha256Hex3(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
 
-// src/sdk/snapshot/constants.ts
+// ../runtime-core/src/sdk/snapshot/constants.ts
 var OPENSTEER_INTERACTIVE_ATTR = "data-opensteer-interactive";
 var OPENSTEER_HIDDEN_ATTR = "data-opensteer-hidden";
 var OPENSTEER_SCROLLABLE_ATTR = "data-opensteer-scrollable";
@@ -19618,7 +20194,7 @@ var VOID_TAGS = /* @__PURE__ */ new Set([
   "wbr"
 ]);
 
-// src/sdk/snapshot/cleaner.ts
+// ../runtime-core/src/sdk/snapshot/cleaner.ts
 var STRIP_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "meta", "link", "template"]);
 var TEXT_ATTR_MAX = 150;
 var URL_ATTR_MAX = 500;
@@ -20058,7 +20634,7 @@ var VOID_TAGS2 = /* @__PURE__ */ new Set([
   "wbr"
 ]);
 
-// src/sdk/snapshot/compiler.ts
+// ../runtime-core/src/sdk/snapshot/compiler.ts
 async function compileOpensteerSnapshot(options) {
   const pageInfo = await options.engine.getPageInfo({ pageRef: options.pageRef });
   const mainSnapshot = await getMainDocumentSnapshot(options.engine, options.pageRef);
@@ -20609,7 +21185,7 @@ async function beautifyScriptContent(content) {
   });
 }
 
-// src/scripts/deobfuscate.ts
+// ../runtime-core/src/scripts/deobfuscate.ts
 async function deobfuscateScriptContent(input) {
   const webcrack = await loadWebcrack();
   const result = await webcrack(input.content, {
@@ -20667,7 +21243,7 @@ function inferTransforms(original, deobfuscated) {
   return [...inferred];
 }
 
-// src/scripts/sandbox-shims/minimal.ts
+// ../runtime-core/src/scripts/sandbox-shims/minimal.ts
 function createMinimalSandboxGlobals(options) {
   return {
     console: options.console,
@@ -20691,7 +21267,7 @@ function createMinimalSandboxGlobals(options) {
   };
 }
 
-// src/scripts/sandbox-shims/standard.ts
+// ../runtime-core/src/scripts/sandbox-shims/standard.ts
 function createStandardSandboxGlobals(options) {
   const globals = createMinimalSandboxGlobals(options);
   const eventApi = createEventTargetApi();
@@ -20962,7 +21538,7 @@ function normalizeErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/scripts/sandbox-shims/full.ts
+// ../runtime-core/src/scripts/sandbox-shims/full.ts
 function createFullSandboxGlobals(options) {
   const globals = createStandardSandboxGlobals(options);
   const eventListeners = /* @__PURE__ */ new WeakMap();
@@ -21082,7 +21658,7 @@ function createFullSandboxGlobals(options) {
   };
 }
 
-// src/scripts/sandbox.ts
+// ../runtime-core/src/scripts/sandbox.ts
 async function runScriptSandbox(input) {
   const startedAt = Date.now();
   const errors = [];
@@ -21306,7 +21882,7 @@ function normalizeErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/captcha/solver-capsolver.ts
+// ../runtime-core/src/captcha/solver-capsolver.ts
 var CAPSOLVER_CREATE_TASK_URL = "https://api.capsolver.com/createTask";
 var CAPSOLVER_GET_TASK_RESULT_URL = "https://api.capsolver.com/getTaskResult";
 function createCapSolver(apiKey) {
@@ -21404,7 +21980,7 @@ function sleep2(ms, signal) {
   });
 }
 
-// src/captcha/solver-2captcha.ts
+// ../runtime-core/src/captcha/solver-2captcha.ts
 var TWO_CAPTCHA_CREATE_TASK_URL = "https://api.2captcha.com/createTask";
 var TWO_CAPTCHA_GET_TASK_RESULT_URL = "https://api.2captcha.com/getTaskResult";
 function createTwoCaptchaSolver(apiKey) {
@@ -21502,7 +22078,7 @@ function sleep3(ms, signal) {
   });
 }
 
-// src/captcha/detect.ts
+// ../runtime-core/src/captcha/detect.ts
 var CAPTCHA_DETECTION_SCRIPT = `(() => {
   const pageUrl = location.href;
   const findSiteKey = (selectors) => {
@@ -21564,7 +22140,7 @@ async function detectCaptchaOnPage(engine, pageRef) {
   return candidate;
 }
 
-// src/captcha/inject.ts
+// ../runtime-core/src/captcha/inject.ts
 async function injectCaptchaToken(input) {
   const result = await input.engine.evaluatePage({
     pageRef: input.pageRef,
@@ -21620,7 +22196,7 @@ var CAPTCHA_INJECTION_SCRIPT = `(({ type, token }) => {
   return true;
 })`;
 
-// src/interaction/diff.ts
+// ../runtime-core/src/interaction/diff.ts
 function diffInteractionTraces(left, right) {
   const eventSequenceMismatches = [];
   const eventPropertyMismatches = [];
@@ -21689,20 +22265,17 @@ function diffInteractionTraces(left, right) {
   };
 }
 
-// src/sdk/runtime.ts
+// ../runtime-core/src/sdk/runtime.ts
 var requireForAuthRecipeHook = 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)));
-var OpensteerRuntime = class {
+var OpensteerSessionRuntime = class {
   workspace;
   rootPath;
-  publicWorkspace;
-  configuredBrowser;
-  configuredLaunch;
-  configuredContext;
-  configuredEngineName;
+  workspaceName;
   injectedEngine;
   engineFactory;
   policy;
   cleanupRootOnClose;
+  sessionInfoBase;
   root;
   engine;
   dom;
@@ -21717,35 +22290,46 @@ var OpensteerRuntime = class {
   cookieJars = /* @__PURE__ */ new Map();
   recipeCache = /* @__PURE__ */ new Map();
   ownsEngine = false;
-  constructor(options = {}) {
-    this.publicWorkspace = options.workspace?.trim() === void 0 || options.workspace?.trim().length === 0 ? void 0 : options.workspace.trim();
-    this.workspace = normalizeNamespace3(options.workspace);
-    this.rootPath = options.rootPath ?? (this.publicWorkspace === void 0 ? path6__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : path6__default.default.resolve(
-      options.rootDir ?? process.cwd(),
-      ".opensteer",
-      "workspaces",
-      encodeURIComponent(this.publicWorkspace)
-    ));
-    this.configuredBrowser = options.browser;
-    this.configuredLaunch = options.launch;
-    this.configuredContext = options.context;
-    this.configuredEngineName = options.engineName;
+  constructor(options) {
+    this.workspace = normalizeNamespace3(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 ?? path6__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
     this.injectedEngine = options.engine;
-    this.engineFactory = options.engineFactory ?? ((factoryOptions) => {
-      const browser = factoryOptions.browser ?? this.configuredBrowser;
-      const launch = factoryOptions.launch ?? this.configuredLaunch;
-      const context = factoryOptions.context ?? this.configuredContext;
-      return new OpensteerBrowserManager({
-        rootPath: this.rootPath,
-        ...this.publicWorkspace === void 0 ? {} : { workspace: this.publicWorkspace },
-        ...this.configuredEngineName === void 0 ? {} : { engineName: this.configuredEngineName },
-        ...browser === void 0 ? {} : { browser },
-        ...launch === void 0 ? {} : { launch },
-        ...context === void 0 ? {} : { context }
-      }).createEngine();
-    });
+    this.engineFactory = options.engineFactory;
     this.policy = options.policy ?? defaultPolicy();
-    this.cleanupRootOnClose = options.cleanupRootOnClose ?? this.publicWorkspace === void 0;
+    this.cleanupRootOnClose = options.cleanupRootOnClose ?? options.workspace === void 0;
+    this.sessionInfoBase = options.sessionInfo ?? {};
+    if (this.injectedEngine === void 0 && this.engineFactory === void 0) {
+      throw new Error("OpensteerSessionRuntime requires an engine or engineFactory.");
+    }
+  }
+  async info() {
+    const base = this.sessionInfoBase;
+    return {
+      provider: base.provider ?? {
+        kind: "local",
+        ownership: "owned",
+        engine: "playwright"
+      },
+      ...base.workspace === void 0 ? {} : { workspace: base.workspace },
+      ...this.sessionRef === void 0 ? {} : { sessionId: this.sessionRef },
+      ...this.pageRef === void 0 ? {} : { activePageRef: this.pageRef },
+      reconnectable: base.reconnectable ?? !this.cleanupRootOnClose,
+      capabilities: base.capabilities ?? {
+        semanticOperations: opensteerSemanticOperationNames,
+        instrumentation: {
+          route: true,
+          interceptScript: true,
+          networkStream: false
+        }
+      },
+      ...base.grants === void 0 ? {} : { grants: base.grants },
+      runtime: base.runtime ?? {
+        protocolVersion: OPENSTEER_PROTOCOL_VERSION,
+        runtimeCoreVersion: OPENSTEER_RUNTIME_CORE_VERSION
+      }
+    };
   }
   async open(input = {}, options = {}) {
     assertValidSemanticOperationInput("session.open", input);
@@ -26116,14 +26700,14 @@ var OpensteerRuntime = class {
     return saved;
   }
   resolveCurrentStateSource() {
-    const browser = this.configuredBrowser;
-    if (browser === void 0 || browser === "temporary") {
-      return "temporary";
+    const ownership = this.sessionInfoBase.provider?.ownership;
+    if (ownership === "attached") {
+      return "attach";
     }
-    if (browser === "persistent") {
+    if (this.workspaceName !== void 0 || this.cleanupRootOnClose === false) {
       return "persistent";
     }
-    return "attach";
+    return "temporary";
   }
   async resolveReverseCaseById(caseId) {
     const record = await (await this.ensureRoot()).registry.reverseCases.getById(caseId);
@@ -27690,8 +28274,8 @@ var OpensteerRuntime = class {
   async ensureRoot() {
     this.root ??= await createFilesystemOpensteerWorkspace({
       rootPath: this.rootPath,
-      ...this.publicWorkspace === void 0 ? {} : { workspace: this.publicWorkspace },
-      scope: this.publicWorkspace === void 0 ? "temporary" : "workspace"
+      ...this.workspaceName === void 0 ? {} : { workspace: this.workspaceName },
+      scope: this.workspaceName === void 0 ? "temporary" : "workspace"
     });
     return this.root;
   }
@@ -27704,15 +28288,10 @@ var OpensteerRuntime = class {
       this.ownsEngine = false;
       return this.engine;
     }
-    const browser = overrides.browser ?? this.configuredBrowser;
-    const launch = overrides.launch ?? this.configuredLaunch;
-    const context = overrides.context ?? this.configuredContext;
-    const factoryOptions = {
-      ...browser === void 0 ? {} : { browser },
-      ...launch === void 0 ? {} : { launch },
-      ...context === void 0 ? {} : { context }
-    };
-    this.engine = await this.engineFactory(factoryOptions);
+    if (this.engineFactory === void 0) {
+      throw new Error("Opensteer engine factory is not initialized");
+    }
+    this.engine = await this.engineFactory(overrides);
     this.ownsEngine = true;
     return this.engine;
   }
@@ -28169,6 +28748,9 @@ function parseContentType2(contentType) {
   };
 }
 function toJsonValueOrNull(value) {
+  if (value === void 0) {
+    return null;
+  }
   return toCanonicalJsonValue(value) ?? null;
 }
 function stringifyRecipeVariableValue(value) {
@@ -28966,12 +29548,12 @@ function extractReverseRuntimeValue(value, pointer) {
   }
   return readDotPath(value, pointer);
 }
-function readDotPath(value, path11) {
-  if (path11.length === 0) {
+function readDotPath(value, path13) {
+  if (path13.length === 0) {
     return value;
   }
   let current = value;
-  for (const segment of path11.split(".").filter((entry) => entry.length > 0)) {
+  for (const segment of path13.split(".").filter((entry) => entry.length > 0)) {
     if (current === null || current === void 0) {
       return void 0;
     }
@@ -29444,7 +30026,7 @@ function parseSetCookieHeader(value, requestUrl) {
   }
   const url = new URL(requestUrl);
   let domain = url.hostname;
-  let path11 = defaultCookiePath(url.pathname);
+  let path13 = defaultCookiePath(url.pathname);
   let secure = url.protocol === "https:";
   let expiresAt;
   const cookieValue = rawValueParts.join("=").trim();
@@ -29457,7 +30039,7 @@ function parseSetCookieHeader(value, requestUrl) {
       continue;
     }
     if (key === "path" && attributeValue.length > 0) {
-      path11 = attributeValue;
+      path13 = attributeValue;
       continue;
     }
     if (key === "secure") {
@@ -29483,7 +30065,7 @@ function parseSetCookieHeader(value, requestUrl) {
       name,
       value: cookieValue,
       domain,
-      path: path11,
+      path: path13,
       secure,
       ...expiresAt === void 0 ? {} : { expiresAt }
     }
@@ -30507,6 +31089,100 @@ function screenshotMediaType(format2) {
   }
 }
 
+// src/sdk/runtime.ts
+var OpensteerRuntime = class extends OpensteerSessionRuntime {
+  constructor(options = {}) {
+    const publicWorkspace = normalizeWorkspace2(options.workspace);
+    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path6__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
+      rootDir: path6__default.default.resolve(options.rootDir ?? process.cwd()),
+      workspace: publicWorkspace
+    }));
+    const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
+    const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
+    assertSupportedEngineOptions({
+      engineName,
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...options.context === void 0 ? {} : { context: options.context }
+    });
+    super(buildSharedRuntimeOptions({
+      name: publicWorkspace ?? "default",
+      rootPath,
+      ...publicWorkspace === void 0 ? {} : { workspaceName: publicWorkspace },
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...options.launch === void 0 ? {} : { launch: options.launch },
+      ...options.context === void 0 ? {} : { context: options.context },
+      engineName,
+      ...options.engine === void 0 ? {} : { engine: options.engine },
+      ...options.engineFactory === void 0 ? {} : { engineFactory: options.engineFactory },
+      ...options.policy === void 0 ? {} : { policy: options.policy },
+      cleanupRootOnClose
+    }));
+  }
+};
+var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
+  constructor(options) {
+    const rootPath = options.rootPath ?? path6__default.default.resolve(options.rootDir ?? process.cwd());
+    const cleanupRootOnClose = options.cleanupRootOnClose ?? false;
+    const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
+    assertSupportedEngineOptions({
+      engineName,
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...options.context === void 0 ? {} : { context: options.context }
+    });
+    super(buildSharedRuntimeOptions({
+      name: options.name,
+      rootPath,
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...options.launch === void 0 ? {} : { launch: options.launch },
+      ...options.context === void 0 ? {} : { context: options.context },
+      engineName,
+      ...options.engine === void 0 ? {} : { engine: options.engine },
+      ...options.engineFactory === void 0 ? {} : { engineFactory: options.engineFactory },
+      ...options.policy === void 0 ? {} : { policy: options.policy },
+      cleanupRootOnClose
+    }));
+  }
+};
+function buildSharedRuntimeOptions(input) {
+  const ownership = resolveOwnership(input.browser);
+  const engineFactory = input.engineFactory ?? ((factoryOptions) => new OpensteerBrowserManager({
+    rootPath: input.rootPath,
+    ...input.workspaceName === void 0 ? {} : { workspace: input.workspaceName },
+    engineName: input.engineName,
+    ...(factoryOptions.browser ?? input.browser) === void 0 ? {} : { browser: factoryOptions.browser ?? input.browser },
+    ...(factoryOptions.launch ?? input.launch) === void 0 ? {} : { launch: factoryOptions.launch ?? input.launch },
+    ...(factoryOptions.context ?? input.context) === void 0 ? {} : { context: factoryOptions.context ?? input.context }
+  }).createEngine());
+  return {
+    name: input.name,
+    ...input.workspaceName === void 0 ? {} : { workspaceName: input.workspaceName },
+    rootPath: input.rootPath,
+    ...input.engine === void 0 ? {} : { engine: input.engine },
+    ...input.engine === void 0 ? { engineFactory } : {},
+    ...input.policy === void 0 ? {} : { policy: input.policy },
+    cleanupRootOnClose: input.cleanupRootOnClose,
+    sessionInfo: {
+      provider: {
+        kind: "local",
+        ownership,
+        engine: input.engineName
+      },
+      ...input.workspaceName === void 0 ? {} : { workspace: input.workspaceName },
+      reconnectable: !input.cleanupRootOnClose
+    }
+  };
+}
+function normalizeWorkspace2(workspace) {
+  if (workspace === void 0) {
+    return void 0;
+  }
+  const trimmed = workspace.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+function resolveOwnership(browser) {
+  return typeof browser === "object" && browser.mode === "attach" ? "attached" : "owned";
+}
+
 // src/mode/config.ts
 var OPENSTEER_EXECUTION_MODES = ["local", "cloud"];
 function assertExecutionModeSupportsEngine(mode, engine) {
@@ -30942,14 +31618,14 @@ function toPortableBrowserProfileCookieRecord(cookie) {
   if (!name || !domain) {
     return null;
   }
-  const path11 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
+  const path13 = 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: path11,
+    path: path13,
     secure: cookie.secure,
     httpOnly: cookie.httpOnly,
     ...sameSite === void 0 ? {} : { sameSite },
@@ -31126,6 +31802,18 @@ var OpensteerCloudClient = class {
     });
     return await response.json();
   }
+  async issueAccess(sessionId, capabilities) {
+    const response = await this.request(
+      `/v1/sessions/${encodeURIComponent(sessionId)}/access`,
+      {
+        method: "POST",
+        body: {
+          capabilities
+        }
+      }
+    );
+    return await response.json();
+  }
   async closeSession(sessionId) {
     const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}`, {
       method: "DELETE"
@@ -31331,58 +32019,367 @@ function isFetchFailure(error) {
   }
   return error.name === "TypeError" || /fetch failed/i.test(error.message);
 }
-
-// src/cloud/session-proxy.ts
-var CLOUD_SESSION_LAYOUT = "opensteer-cloud-session";
-var CLOUD_SESSION_VERSION = 1;
-var TEMPORARY_CLOUD_WORKSPACE_PREFIX = "opensteer-cloud-workspace-";
-var SUPPORTED_CLOUD_OPERATIONS = /* @__PURE__ */ new Set([
-  "session.open",
-  "page.goto",
-  "page.snapshot",
-  "dom.click",
-  "dom.hover",
-  "dom.input",
-  "dom.scroll",
-  "dom.extract",
-  "network.query",
-  "network.save",
-  "network.clear",
-  "request.raw",
-  "request-plan.infer",
-  "request-plan.write",
-  "request-plan.get",
-  "request-plan.list",
-  "request.execute",
-  "computer.execute",
-  "session.close"
-]);
-function resolveCloudSessionRecordPath(rootPath) {
-  return path6__default.default.join(rootPath, "live", "cloud-session.json");
+var OpensteerCloudAutomationError = class extends Error {
+  opensteerError;
+  constructor(error) {
+    super(error.message);
+    this.name = "OpensteerCloudAutomationError";
+    this.opensteerError = error;
+  }
+};
+var OpensteerCloudAutomationClient = class {
+  constructor(cloud, sessionId) {
+    this.cloud = cloud;
+    this.sessionId = sessionId;
+  }
+  socket;
+  connectPromise;
+  pending = /* @__PURE__ */ new Map();
+  routes = /* @__PURE__ */ new Map();
+  grant;
+  async invoke(operation, input) {
+    await this.ensureConnected();
+    const requestId = `automation:${crypto.randomUUID()}`;
+    const message = {
+      protocol: OPENSTEER_PROTOCOL_NAME,
+      version: OPENSTEER_PROTOCOL_VERSION,
+      kind: "invoke",
+      requestId,
+      operation,
+      sentAt: Date.now(),
+      ...input === void 0 ? {} : { input }
+    };
+    return new Promise((resolve5, reject) => {
+      this.pending.set(requestId, {
+        resolve: (value) => resolve5(value),
+        reject
+      });
+      try {
+        this.requireSocket().send(JSON.stringify(message));
+      } catch (error) {
+        this.pending.delete(requestId);
+        reject(error);
+      }
+    });
+  }
+  async getSessionInfo() {
+    const result = await this.invoke("session.info", {});
+    const sessionInfo = result;
+    assertCompatibleRuntimeCoreVersion(sessionInfo);
+    return sessionInfo;
+  }
+  async route(input) {
+    const routeId = `route:${crypto.randomUUID()}`;
+    const registration = await this.invoke("route.register", {
+      routeId,
+      ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef },
+      urlPattern: input.urlPattern,
+      ...input.resourceTypes === void 0 ? {} : { resourceTypes: input.resourceTypes },
+      ...input.times === void 0 ? {} : { times: input.times },
+      includeOriginal: true
+    });
+    this.routes.set(routeId, {
+      kind: "route",
+      routeId,
+      input
+    });
+    return registration;
+  }
+  async interceptScript(input) {
+    const routeId = `route:${crypto.randomUUID()}`;
+    const registration = await this.invoke("route.register", {
+      routeId,
+      ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef },
+      urlPattern: input.urlPattern,
+      resourceTypes: ["script"],
+      ...input.times === void 0 ? {} : { times: input.times },
+      includeOriginal: true
+    });
+    this.routes.set(routeId, {
+      kind: "intercept-script",
+      routeId,
+      input
+    });
+    return registration;
+  }
+  async close() {
+    this.connectPromise = void 0;
+    this.grant = void 0;
+    if (!this.socket) {
+      return;
+    }
+    const socket = this.socket;
+    this.socket = void 0;
+    for (const [requestId, pending] of this.pending) {
+      pending.reject(new Error(`automation connection closed before ${requestId} completed`));
+    }
+    this.pending.clear();
+    await new Promise((resolve5) => {
+      socket.once("close", () => resolve5());
+      socket.close();
+    }).catch(() => void 0);
+  }
+  async ensureConnected() {
+    if (this.socket?.readyState === WebSocket2__default.default.OPEN) {
+      return;
+    }
+    if (this.connectPromise) {
+      await this.connectPromise;
+      return;
+    }
+    this.connectPromise = this.connect();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = void 0;
+    }
+  }
+  async connect() {
+    const grant = await this.issueGrant("automation");
+    const wsUrl = new URL(grant.wsUrl);
+    wsUrl.searchParams.set("token", grant.token);
+    const socket = new WebSocket2__default.default(wsUrl);
+    this.socket = socket;
+    socket.on("message", (data, isBinary) => {
+      if (isBinary) {
+        return;
+      }
+      this.handleMessage(data.toString());
+    });
+    socket.on("close", () => {
+      if (this.socket === socket) {
+        this.socket = void 0;
+      }
+    });
+    socket.on("error", (error) => {
+      for (const pending of this.pending.values()) {
+        pending.reject(error);
+      }
+      this.pending.clear();
+    });
+    await new Promise((resolve5, reject) => {
+      socket.once("open", () => resolve5());
+      socket.once("error", reject);
+    });
+    this.send({
+      protocol: OPENSTEER_PROTOCOL_NAME,
+      version: OPENSTEER_PROTOCOL_VERSION,
+      kind: "hello",
+      sessionId: this.sessionId,
+      grantKind: grant.kind
+    });
+    await this.restoreRoutes();
+  }
+  async restoreRoutes() {
+    const stored = [...this.routes.values()];
+    this.routes.clear();
+    for (const registration of stored) {
+      if (registration.kind === "route") {
+        await this.route(registration.input);
+      } else {
+        await this.interceptScript(
+          registration.input
+        );
+      }
+    }
+  }
+  handleMessage(json) {
+    const message = JSON.parse(json);
+    if (message.protocol !== OPENSTEER_PROTOCOL_NAME) {
+      return;
+    }
+    switch (message.kind) {
+      case "result": {
+        const pending = this.pending.get(message.requestId);
+        if (!pending) {
+          return;
+        }
+        this.pending.delete(message.requestId);
+        pending.resolve(message.data);
+        return;
+      }
+      case "error": {
+        if (!message.requestId) {
+          return;
+        }
+        const pending = this.pending.get(message.requestId);
+        if (!pending) {
+          return;
+        }
+        this.pending.delete(message.requestId);
+        pending.reject(new OpensteerCloudAutomationError(message.error));
+        return;
+      }
+      case "event":
+        void this.handleEvent(message.event, message.data);
+        return;
+      case "pong":
+        return;
+    }
+  }
+  async handleEvent(event, payload) {
+    if (event !== "route.request") {
+      return;
+    }
+    const data = asRecord(payload);
+    const request = asRecord(data.request);
+    const original = asRecord(data.original);
+    const routeId = typeof data.routeId === "string" ? data.routeId : "";
+    const routeRequestId = typeof data.routeRequestId === "string" ? data.routeRequestId : "";
+    if (!routeId || !routeRequestId) {
+      return;
+    }
+    const registration = this.routes.get(routeId);
+    if (!registration) {
+      await this.invoke("route.resolve", {
+        routeRequestId,
+        decision: { kind: "continue" }
+      }).catch(() => void 0);
+      return;
+    }
+    try {
+      const decision = registration.kind === "route" ? await registration.input.handler({
+        request: toRouteRequest(request),
+        fetchOriginal: async () => toFetchedRouteResponse(original)
+      }) : {
+        kind: "fulfill",
+        body: await registration.input.handler({
+          url: typeof request.url === "string" ? request.url : "",
+          content: typeof original.body === "string" ? original.body : "",
+          headers: Array.isArray(original.headers) ? original.headers.filter(isHeaderEntry) : [],
+          status: typeof original.status === "number" ? original.status : 200
+        }),
+        headers: Array.isArray(original.headers) ? original.headers.filter(isHeaderEntry) : [],
+        status: typeof original.status === "number" ? original.status : 200,
+        contentType: findHeaderValue(
+          Array.isArray(original.headers) ? original.headers.filter(isHeaderEntry) : [],
+          "content-type"
+        ) ?? "application/javascript; charset=utf-8"
+      };
+      await this.invoke("route.resolve", {
+        routeRequestId,
+        decision: serializeRouteDecision(decision)
+      }).catch(() => void 0);
+    } catch {
+      await this.invoke("route.resolve", {
+        routeRequestId,
+        decision: { kind: "continue" }
+      }).catch(() => void 0);
+    }
+  }
+  async issueGrant(kind) {
+    if (this.grant && this.grant.kind === kind && this.grant.expiresAt > Date.now() + 1e4) {
+      return this.grant;
+    }
+    const issued = await this.cloud.issueAccess(this.sessionId, [kind]);
+    const grant = issued.grants[kind];
+    if (!grant) {
+      throw new OpensteerCloudAutomationError(
+        createOpensteerError(
+          "permission-denied",
+          `cloud did not issue an ${kind} automation grant`
+        )
+      );
+    }
+    this.grant = grant;
+    return grant;
+  }
+  requireSocket() {
+    if (!this.socket || this.socket.readyState !== WebSocket2__default.default.OPEN) {
+      throw new Error("cloud automation socket is not connected");
+    }
+    return this.socket;
+  }
+  send(message) {
+    this.requireSocket().send(JSON.stringify(message));
+  }
+};
+function assertCompatibleRuntimeCoreVersion(sessionInfo) {
+  const runtimeCoreVersion = sessionInfo.runtime?.runtimeCoreVersion;
+  if (runtimeCoreVersion === void 0) {
+    return;
+  }
+  const expectedMajor = parseMajorVersion(OPENSTEER_RUNTIME_CORE_VERSION);
+  const actualMajor = parseMajorVersion(runtimeCoreVersion);
+  if (expectedMajor === null || actualMajor === null || expectedMajor === actualMajor) {
+    return;
+  }
+  throw new Error(
+    `cloud runtime-core major version ${runtimeCoreVersion} is incompatible with local SDK runtime-core ${OPENSTEER_RUNTIME_CORE_VERSION}`
+  );
 }
-async function readPersistedCloudSessionRecord(rootPath) {
-  const sessionPath = resolveCloudSessionRecordPath(rootPath);
-  if (!await pathExists(sessionPath)) {
-    return void 0;
+function parseMajorVersion(version) {
+  const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
+  return Number.isFinite(major) ? major : null;
+}
+function serializeRouteDecision(decision) {
+  if (decision.kind === "continue") {
+    return { kind: "continue" };
   }
-  const parsed = await readJsonFile(sessionPath);
-  if (parsed.layout !== CLOUD_SESSION_LAYOUT || parsed.version !== CLOUD_SESSION_VERSION || parsed.mode !== "cloud" || typeof parsed.sessionId !== "string" || parsed.sessionId.length === 0 || typeof parsed.baseUrl !== "string" || parsed.baseUrl.length === 0 || typeof parsed.startedAt !== "number" || !Number.isFinite(parsed.startedAt) || typeof parsed.updatedAt !== "number" || !Number.isFinite(parsed.updatedAt)) {
-    return void 0;
+  if (decision.kind === "abort") {
+    return {
+      kind: "abort",
+      ...decision.errorCode === void 0 ? {} : { errorCode: decision.errorCode }
+    };
   }
   return {
-    layout: CLOUD_SESSION_LAYOUT,
-    version: CLOUD_SESSION_VERSION,
-    mode: "cloud",
-    ...parsed.workspace === void 0 ? {} : { workspace: parsed.workspace },
-    sessionId: parsed.sessionId,
-    baseUrl: parsed.baseUrl,
-    startedAt: parsed.startedAt,
-    updatedAt: parsed.updatedAt
+    kind: "fulfill",
+    ...decision.status === void 0 ? {} : { status: decision.status },
+    ...decision.headers === void 0 ? {} : { headers: decision.headers },
+    ...decision.body === void 0 ? {} : typeof decision.body === "string" ? { body: decision.body } : { bodyBase64: Buffer.from(decision.body).toString("base64") },
+    ...decision.contentType === void 0 ? {} : { contentType: decision.contentType }
   };
 }
-async function hasPersistedCloudSession(rootPath) {
-  return await readPersistedCloudSessionRecord(rootPath) !== void 0;
+function toRouteRequest(record) {
+  const pageRef = typeof record.pageRef === "string" ? record.pageRef : void 0;
+  return {
+    url: typeof record.url === "string" ? record.url : "",
+    method: typeof record.method === "string" ? record.method : "GET",
+    headers: Array.isArray(record.headers) ? record.headers.filter(isHeaderEntry) : [],
+    resourceType: typeof record.resourceType === "string" ? record.resourceType : "other",
+    ...pageRef === void 0 ? {} : { pageRef },
+    ...typeof record.postData === "string" ? {
+      postData: {
+        bytes: Uint8Array.from(Buffer.from(record.postData)),
+        encoding: "identity",
+        truncated: false,
+        capturedByteLength: Buffer.byteLength(record.postData)
+      }
+    } : {}
+  };
 }
+function toFetchedRouteResponse(record) {
+  return {
+    url: typeof record.url === "string" ? record.url : "",
+    status: typeof record.status === "number" ? record.status : 200,
+    statusText: typeof record.statusText === "string" ? record.statusText : "OK",
+    headers: Array.isArray(record.headers) ? record.headers.filter(isHeaderEntry) : [],
+    ...typeof record.body === "string" ? {
+      body: {
+        bytes: Uint8Array.from(Buffer.from(record.body)),
+        encoding: "identity",
+        truncated: false,
+        capturedByteLength: Buffer.byteLength(record.body)
+      }
+    } : {},
+    redirected: Boolean(record.redirected)
+  };
+}
+function findHeaderValue(headers, name) {
+  return headers.find((header) => header.name.toLowerCase() === name)?.value;
+}
+function isHeaderEntry(value) {
+  return value !== null && typeof value === "object" && typeof value.name === "string" && typeof value.value === "string";
+}
+function asRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+
+// src/cloud/session-proxy.ts
+var TEMPORARY_CLOUD_WORKSPACE_PREFIX = "opensteer-cloud-workspace-";
 var CloudSessionProxy = class {
   rootPath;
   workspace;
@@ -31391,6 +32388,7 @@ var CloudSessionProxy = class {
   sessionId;
   sessionBaseUrl;
   client;
+  automation;
   workspaceStore;
   constructor(cloud, options = {}) {
     this.cloud = cloud;
@@ -31411,27 +32409,73 @@ var CloudSessionProxy = class {
       ...input.url === void 0 ? {} : { url: input.url }
     });
   }
+  async info() {
+    const persisted = this.client !== void 0 || this.sessionId !== void 0 ? void 0 : await this.loadPersistedSession();
+    if (this.client === void 0 && this.sessionId === void 0 && persisted !== void 0 && await this.isReusableCloudSession(persisted.sessionId)) {
+      this.bindClient(persisted);
+    }
+    if (this.automation) {
+      try {
+        const sessionInfo = await this.automation.getSessionInfo();
+        return {
+          ...sessionInfo,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace }
+        };
+      } catch {
+      }
+    }
+    return {
+      provider: {
+        kind: "cloud",
+        ownership: "managed",
+        engine: "playwright",
+        baseUrl: this.cloud.getConfig().baseUrl
+      },
+      ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+      ...this.sessionId === void 0 ? persisted?.sessionId === void 0 ? {} : { sessionId: persisted.sessionId } : { sessionId: this.sessionId },
+      reconnectable: this.workspace !== void 0 || this.sessionId !== void 0 || persisted !== void 0,
+      capabilities: {
+        semanticOperations: opensteerSemanticOperationNames,
+        sessionGrants: ["automation", "view", "cdp"],
+        instrumentation: {
+          route: true,
+          interceptScript: true,
+          networkStream: true
+        }
+      },
+      runtime: {
+        protocolVersion: OPENSTEER_PROTOCOL_VERSION,
+        runtimeCoreVersion: OPENSTEER_RUNTIME_CORE_VERSION
+      }
+    };
+  }
   async listPages(input = {}) {
-    throw unsupportedCloudOperation("page.list");
+    await this.ensureSession();
+    return this.requireClient().invoke("page.list", input);
   }
   async newPage(input = {}) {
-    throw unsupportedCloudOperation("page.new");
+    await this.ensureSession();
+    return this.requireAutomation().invoke("page.new", input);
   }
   async activatePage(input) {
-    throw unsupportedCloudOperation("page.activate");
+    await this.ensureSession();
+    return this.requireClient().invoke("page.activate", input);
   }
   async closePage(input = {}) {
-    throw unsupportedCloudOperation("page.close");
+    await this.ensureSession();
+    return this.requireClient().invoke("page.close", input);
   }
   async goto(input) {
     await this.ensureSession();
     return this.requireClient().invoke("page.goto", input);
   }
   async evaluate(input) {
-    throw unsupportedCloudOperation("page.evaluate");
+    await this.ensureSession();
+    return this.requireAutomation().invoke("page.evaluate", input);
   }
   async addInitScript(input) {
-    throw unsupportedCloudOperation("page.add-init-script");
+    await this.ensureSession();
+    return this.requireClient().invoke("page.add-init-script", input);
   }
   async snapshot(input = {}) {
     await this.ensureSession();
@@ -31466,80 +32510,112 @@ var CloudSessionProxy = class {
     return this.requireClient().invoke("network.save", input);
   }
   async minimizeNetwork(input) {
-    throw unsupportedCloudOperation("network.minimize");
+    await this.ensureSession();
+    return this.requireClient().invoke("network.minimize", input);
   }
   async diffNetwork(input) {
-    throw unsupportedCloudOperation("network.diff");
+    await this.ensureSession();
+    return this.requireClient().invoke("network.diff", input);
   }
   async probeNetwork(input) {
-    throw unsupportedCloudOperation("network.probe");
+    await this.ensureSession();
+    return this.requireClient().invoke("network.probe", input);
   }
   async discoverReverse(input) {
-    throw unsupportedCloudOperation("reverse.discover");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.discover", input);
   }
   async queryReverse(input) {
-    throw unsupportedCloudOperation("reverse.query");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.query", input);
   }
   async createReversePackage(input) {
-    throw unsupportedCloudOperation("reverse.package.create");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.create", input);
   }
   async runReversePackage(input) {
-    throw unsupportedCloudOperation("reverse.package.run");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.run", input);
   }
   async exportReverse(input) {
-    throw unsupportedCloudOperation("reverse.export");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.export", input);
   }
   async getReverseReport(input) {
-    throw unsupportedCloudOperation("reverse.report");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.report", input);
   }
   async getReversePackage(input) {
-    throw unsupportedCloudOperation("reverse.package.get");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.get", input);
   }
   async listReversePackages(input = {}) {
-    throw unsupportedCloudOperation("reverse.package.list");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.list", input);
   }
   async patchReversePackage(input) {
-    throw unsupportedCloudOperation("reverse.package.patch");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.patch", input);
   }
   async captureInteraction(input) {
-    throw unsupportedCloudOperation("interaction.capture");
+    await this.ensureSession();
+    return this.requireClient().invoke("interaction.capture", input);
   }
   async getInteraction(input) {
-    throw unsupportedCloudOperation("interaction.get");
+    await this.ensureSession();
+    return this.requireClient().invoke("interaction.get", input);
   }
   async diffInteraction(input) {
-    throw unsupportedCloudOperation("interaction.diff");
+    await this.ensureSession();
+    return this.requireClient().invoke("interaction.diff", input);
   }
   async replayInteraction(input) {
-    throw unsupportedCloudOperation("interaction.replay");
+    await this.ensureSession();
+    return this.requireClient().invoke("interaction.replay", input);
   }
   async clearNetwork(input = {}) {
     await this.ensureSession();
     return this.requireClient().invoke("network.clear", input);
   }
   async captureScripts(input = {}) {
-    throw unsupportedCloudOperation("scripts.capture");
+    await this.ensureSession();
+    return this.requireClient().invoke("scripts.capture", input);
   }
   async readArtifact(input) {
-    throw unsupportedCloudOperation("artifact.read");
+    await this.ensureSession();
+    return this.requireClient().invoke("artifact.read", input);
   }
   async beautifyScript(input) {
-    throw unsupportedCloudOperation("scripts.beautify");
+    await this.ensureSession();
+    return this.requireClient().invoke("scripts.beautify", input);
   }
   async deobfuscateScript(input) {
-    throw unsupportedCloudOperation("scripts.deobfuscate");
+    await this.ensureSession();
+    return this.requireClient().invoke("scripts.deobfuscate", input);
   }
   async sandboxScript(input) {
-    throw unsupportedCloudOperation("scripts.sandbox");
+    await this.ensureSession();
+    return this.requireClient().invoke("scripts.sandbox", input);
   }
   async solveCaptcha(input) {
-    throw unsupportedCloudOperation("captcha.solve");
+    await this.ensureSession();
+    return this.requireClient().invoke("captcha.solve", input);
   }
   async getCookies(input = {}) {
-    throw unsupportedCloudOperation("inspect.cookies");
+    await this.ensureSession();
+    return this.requireAutomation().invoke("inspect.cookies", input);
+  }
+  async route(input) {
+    await this.ensureSession();
+    return this.requireAutomation().route(input);
+  }
+  async interceptScript(input) {
+    await this.ensureSession();
+    return this.requireAutomation().interceptScript(input);
   }
   async getStorageSnapshot(input = {}) {
-    throw unsupportedCloudOperation("inspect.storage");
+    await this.ensureSession();
+    return this.requireClient().invoke("inspect.storage", input);
   }
   async rawRequest(input) {
     await this.ensureSession();
@@ -31562,28 +32638,36 @@ var CloudSessionProxy = class {
     return this.requireClient().invoke("request-plan.list", input);
   }
   async writeAuthRecipe(input) {
-    throw unsupportedCloudOperation("auth-recipe.write");
+    await this.ensureSession();
+    return this.requireClient().invoke("auth-recipe.write", input);
   }
   async writeRecipe(input) {
-    throw unsupportedCloudOperation("recipe.write");
+    await this.ensureSession();
+    return this.requireClient().invoke("recipe.write", input);
   }
   async getAuthRecipe(input) {
-    throw unsupportedCloudOperation("auth-recipe.get");
+    await this.ensureSession();
+    return this.requireClient().invoke("auth-recipe.get", input);
   }
   async getRecipe(input) {
-    throw unsupportedCloudOperation("recipe.get");
+    await this.ensureSession();
+    return this.requireClient().invoke("recipe.get", input);
   }
   async listAuthRecipes(input = {}) {
-    throw unsupportedCloudOperation("auth-recipe.list");
+    await this.ensureSession();
+    return this.requireClient().invoke("auth-recipe.list", input);
   }
   async listRecipes(input = {}) {
-    throw unsupportedCloudOperation("recipe.list");
+    await this.ensureSession();
+    return this.requireClient().invoke("recipe.list", input);
   }
   async runAuthRecipe(input) {
-    throw unsupportedCloudOperation("auth-recipe.run");
+    await this.ensureSession();
+    return this.requireClient().invoke("auth-recipe.run", input);
   }
   async runRecipe(input) {
-    throw unsupportedCloudOperation("recipe.run");
+    await this.ensureSession();
+    return this.requireClient().invoke("recipe.run", input);
   }
   async request(input) {
     await this.ensureSession();
@@ -31595,8 +32679,9 @@ var CloudSessionProxy = class {
   }
   async close() {
     const session = await this.loadPersistedSession() ?? (this.sessionId === void 0 || this.sessionBaseUrl === void 0 ? void 0 : {
-      layout: CLOUD_SESSION_LAYOUT,
-      version: CLOUD_SESSION_VERSION,
+      layout: "opensteer-session",
+      version: 1,
+      provider: "cloud",
       mode: "cloud",
       ...this.workspace === void 0 ? {} : { workspace: this.workspace },
       sessionId: this.sessionId,
@@ -31614,7 +32699,9 @@ var CloudSessionProxy = class {
         });
       }
     } finally {
+      await this.automation?.close().catch(() => void 0);
       await this.clearPersistedSession();
+      this.automation = void 0;
       this.client = void 0;
       this.sessionId = void 0;
       this.sessionBaseUrl = void 0;
@@ -31630,6 +32717,8 @@ var CloudSessionProxy = class {
       return;
     }
     this.client = void 0;
+    await this.automation?.close().catch(() => void 0);
+    this.automation = void 0;
     this.sessionId = void 0;
     this.sessionBaseUrl = void 0;
   }
@@ -31650,8 +32739,9 @@ var CloudSessionProxy = class {
       ...resolveCloudBrowserProfile(this.cloud, input) === void 0 ? {} : { browserProfile: resolveCloudBrowserProfile(this.cloud, input) }
     });
     const record = {
-      layout: CLOUD_SESSION_LAYOUT,
-      version: CLOUD_SESSION_VERSION,
+      layout: "opensteer-session",
+      version: 1,
+      provider: "cloud",
       mode: "cloud",
       ...this.workspace === void 0 ? {} : { workspace: this.workspace },
       sessionId: session.sessionId,
@@ -31669,6 +32759,7 @@ var CloudSessionProxy = class {
       baseUrl: record.baseUrl,
       getAuthorizationHeader: async () => this.cloud.buildAuthorizationHeader()
     });
+    this.automation = new OpensteerCloudAutomationClient(this.cloud, record.sessionId);
   }
   async ensureWorkspaceStore() {
     if (this.workspaceStore !== void 0) {
@@ -31687,10 +32778,10 @@ var CloudSessionProxy = class {
   }
   async writePersistedSession(record) {
     const workspace = await this.ensureWorkspaceStore();
-    await writeJsonFileAtomic(resolveCloudSessionRecordPath(workspace.rootPath), record);
+    await writePersistedSessionRecord(workspace.rootPath, record);
   }
   async clearPersistedSession() {
-    await promises.rm(resolveCloudSessionRecordPath(this.rootPath), { force: true }).catch(() => void 0);
+    await clearPersistedSessionRecord(this.rootPath).catch(() => void 0);
   }
   async isReusableCloudSession(sessionId) {
     try {
@@ -31709,6 +32800,12 @@ var CloudSessionProxy = class {
     }
     return this.client;
   }
+  requireAutomation() {
+    if (!this.automation) {
+      throw new Error("Cloud automation session has not been initialized.");
+    }
+    return this.automation;
+  }
 };
 function resolveCloudBrowserProfile(cloud, input) {
   return input.browserProfile ?? cloud.getConfig().browserProfile;
@@ -31724,22 +32821,24 @@ function assertSupportedCloudBrowserMode(browser) {
 function isMissingCloudSessionError(error) {
   return error instanceof Error && /\b404\b/.test(error.message);
 }
-function unsupportedCloudOperation(operation) {
-  return new OpensteerProtocolError(
-    "unsupported-operation",
-    `Cloud mode does not currently support ${operation}.`,
-    {
-      details: {
-        mode: "cloud",
-        operation,
-        supportedOperations: [...SUPPORTED_CLOUD_OPERATIONS]
-      }
-    }
-  );
-}
 
 // src/sdk/runtime-resolution.ts
 function resolveOpensteerRuntimeConfig(input = {}) {
+  if (input.provider?.kind === "cloud") {
+    return {
+      mode: "cloud",
+      cloud: resolveCloudConfig({
+        enabled: true,
+        ...input.provider,
+        mode: "cloud"
+      })
+    };
+  }
+  if (input.provider?.kind === "local") {
+    return {
+      mode: "local"
+    };
+  }
   const mode = resolveOpensteerExecutionMode({
     ...input.mode === void 0 ? {} : { explicit: input.mode },
     cloud: input.cloud !== void 0 && input.cloud !== false,
@@ -31762,6 +32861,7 @@ function createOpensteerSemanticRuntime(input = {}) {
   const engine = input.engine ?? runtimeOptions.engineName ?? DEFAULT_OPENSTEER_ENGINE;
   const config = resolveOpensteerRuntimeConfig({
     ...input.cloud === void 0 ? {} : { cloud: input.cloud },
+    ...input.provider === void 0 ? {} : { provider: input.provider },
     ...input.mode === void 0 ? {} : { mode: input.mode },
     ...process.env.OPENSTEER_MODE === void 0 ? {} : { environmentMode: process.env.OPENSTEER_MODE }
   });
@@ -31788,6 +32888,7 @@ var Opensteer = class {
   constructor(options = {}) {
     const runtimeConfig = resolveOpensteerRuntimeConfig({
       ...options.cloud === void 0 ? {} : { cloud: options.cloud },
+      ...options.provider === void 0 ? {} : { provider: options.provider },
       ...process.env.OPENSTEER_MODE === void 0 ? {} : { environmentMode: process.env.OPENSTEER_MODE }
     });
     if (runtimeConfig.mode === "cloud") {
@@ -31795,6 +32896,7 @@ var Opensteer = class {
       this.runtime = createOpensteerSemanticRuntime({
         mode: runtimeConfig.mode,
         ...options.cloud === void 0 ? {} : { cloud: options.cloud },
+        ...options.provider === void 0 ? {} : { provider: options.provider },
         ...options.engineName === void 0 ? {} : { engine: options.engineName },
         runtimeOptions: {
           ...options
@@ -31815,6 +32917,7 @@ var Opensteer = class {
     this.runtime = createOpensteerSemanticRuntime({
       mode: runtimeConfig.mode,
       ...options.cloud === void 0 ? {} : { cloud: options.cloud },
+      ...options.provider === void 0 ? {} : { provider: options.provider },
       ...options.engineName === void 0 ? {} : { engine: options.engineName },
       runtimeOptions: {
         ...options,
@@ -31832,6 +32935,9 @@ var Opensteer = class {
   async open(input = {}) {
     return this.runtime.open(typeof input === "string" ? { url: input } : input);
   }
+  async info() {
+    return this.runtime.info();
+  }
   async listPages(input = {}) {
     return this.runtime.listPages(input);
   }
@@ -32090,12 +33196,15 @@ var Opensteer = class {
     await this.runtime.disconnect();
   }
   requireOwnedInstrumentationRuntime(method) {
-    if (this.runtime instanceof OpensteerRuntime) {
+    if (isInstrumentableRuntime(this.runtime)) {
       return this.runtime;
     }
-    throw new Error(`${method}() is only available on owned local SDK sessions.`);
+    throw new Error(`${method}() is not available for this session runtime.`);
   }
 };
+function isInstrumentableRuntime(runtime) {
+  return typeof runtime.route === "function" && typeof runtime.interceptScript === "function";
+}
 function createUnsupportedBrowserController() {
   const fail = async () => {
     throw new Error("browser.* helpers are only available in local mode.");
@@ -32162,11 +33271,13 @@ exports.OpensteerAttachAmbiguousError = OpensteerAttachAmbiguousError;
 exports.OpensteerBrowserManager = OpensteerBrowserManager;
 exports.OpensteerCloudClient = OpensteerCloudClient;
 exports.OpensteerRuntime = OpensteerRuntime;
+exports.OpensteerSessionRuntime = OpensteerSessionRuntime2;
 exports.STABLE_PRIMARY_ATTR_KEYS = STABLE_PRIMARY_ATTR_KEYS;
 exports.buildArrayFieldPathCandidates = buildArrayFieldPathCandidates;
 exports.buildPathCandidates = buildPathCandidates;
 exports.buildPathSelectorHint = buildPathSelectorHint;
 exports.buildSegmentSelector = buildSegmentSelector;
+exports.clearPersistedSessionRecord = clearPersistedSessionRecord;
 exports.cloneElementPath = cloneElementPath;
 exports.cloneReplayElementPath = cloneReplayElementPath;
 exports.cloneStructuralElementAnchor = cloneStructuralElementAnchor;
@@ -32191,11 +33302,14 @@ exports.normalizeOpensteerEngineName = normalizeOpensteerEngineName;
 exports.normalizeOpensteerExecutionMode = normalizeOpensteerExecutionMode;
 exports.normalizeWorkspaceId = normalizeWorkspaceId;
 exports.readPersistedCloudSessionRecord = readPersistedCloudSessionRecord;
+exports.readPersistedLocalBrowserSessionRecord = readPersistedLocalBrowserSessionRecord;
+exports.readPersistedSessionRecord = readPersistedSessionRecord;
 exports.resolveCloudConfig = resolveCloudConfig;
-exports.resolveCloudSessionRecordPath = resolveCloudSessionRecordPath;
+exports.resolveCloudSessionRecordPath = resolveLiveSessionRecordPath;
 exports.resolveDomActionBridge = resolveDomActionBridge;
 exports.resolveExtractedValueInContext = resolveExtractedValueInContext;
 exports.resolveFilesystemWorkspacePath = resolveFilesystemWorkspacePath;
+exports.resolveLiveSessionRecordPath = resolveLiveSessionRecordPath;
 exports.resolveOpensteerEngineName = resolveOpensteerEngineName;
 exports.resolveOpensteerExecutionMode = resolveOpensteerExecutionMode;
 exports.resolveOpensteerRuntimeConfig = resolveOpensteerRuntimeConfig;
@@ -32205,5 +33319,6 @@ exports.sanitizeReplayElementPath = sanitizeReplayElementPath;
 exports.sanitizeStructuralElementAnchor = sanitizeStructuralElementAnchor;
 exports.settleWithPolicy = settleWithPolicy;
 exports.shouldKeepAttributeForPath = shouldKeepAttributeForPath;
+exports.writePersistedSessionRecord = writePersistedSessionRecord;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map