opensteer 0.8.7 → 0.8.9

package/dist/{chunk-IAA57HNW.js → chunk-RO6WAWWG.js}

@@ -1,6 +1,6 @@
-import path6, { join, resolve, basename, relative } from 'path';
-import { createHash, randomUUID } from 'crypto';
-import { access, rm, mkdtemp, mkdir, readFile, cp, readdir, writeFile, rename, stat, copyFile, open } from 'fs/promises';
+import path7, { join, resolve, basename, relative } from 'path';
+import { createHash, randomUUID, pbkdf2Sync, createDecipheriv } from 'crypto';
+import { access, rm, mkdtemp, mkdir, readFile, cp, readdir, open, writeFile, rename, stat, copyFile } from 'fs/promises';
 import { pathToFileURL } from 'url';
 import { selectAll } from 'css-select';
 import { execFileSync, execFile, spawn } from 'child_process';
@@ -8,6 +8,7 @@ import { existsSync, readFileSync } from 'fs';
 import { tmpdir, homedir } from 'os';
 import { connectPlaywrightChromiumBrowser, createPlaywrightBrowserCoreEngine, disconnectPlaywrightChromiumBrowser } from '@opensteer/engine-playwright';
 import { promisify } from 'util';
+import { AsyncLocalStorage } from 'async_hooks';
 import { createRequire } from 'module';
 import sharp from 'sharp';
 import * as cheerio from 'cheerio';
@@ -16,15 +17,12 @@ import vm from 'vm';
 import { gzip as gzip$1 } from 'zlib';
 import WebSocket2 from 'ws';
 
-// ../protocol/src/dom-action-bridge.ts
-var OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@opensteer/dom-action-bridge");
-function isDomActionBridgeFactory(value) {
-  return typeof value === "function";
-}
-function resolveDomActionBridge(engine) {
-  const candidate = Reflect.get(engine, OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL);
-  return isDomActionBridgeFactory(candidate) ? candidate.call(engine) : void 0;
-}
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // ../runtime-core/src/json.ts
 function isPlainObject(value) {
@@ -34,30 +32,30 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function canonicalizeJsonValue(value, path13) {
+function canonicalizeJsonValue(value, path15) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new TypeError(`${path13} must be a finite JSON number`);
+      throw new TypeError(`${path15} must be a finite JSON number`);
     }
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path13}[${index}]`));
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path15}[${index}]`));
   }
   if (!isPlainObject(value)) {
-    throw new TypeError(`${path13} must be a plain JSON object`);
+    throw new TypeError(`${path15} 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(`${path13}.${key} must not be undefined`);
+      throw new TypeError(`${path15}.${key} must not be undefined`);
     }
-    result[key] = canonicalizeJsonValue(entry, `${path13}.${key}`);
+    result[key] = canonicalizeJsonValue(entry, `${path15}.${key}`);
   }
   return result;
 }
@@ -94,7 +92,7 @@ function joinStoragePath(...segments) {
   return segments.join("/");
 }
 function resolveStoragePath(rootPath, relativePath) {
-  if (path6.isAbsolute(relativePath)) {
+  if (path7.isAbsolute(relativePath)) {
     throw new TypeError(`storage path ${relativePath} must be relative`);
   }
   const segments = relativePath.split("/");
@@ -106,7 +104,7 @@ function resolveStoragePath(rootPath, relativePath) {
       throw new TypeError(`storage path ${relativePath} must not contain path traversal`);
     }
   }
-  return path6.join(rootPath, ...segments);
+  return path7.join(rootPath, ...segments);
 }
 async function ensureDirectory(directoryPath) {
   await mkdir(directoryPath, { recursive: true });
@@ -126,7 +124,7 @@ async function writeJsonFileAtomic(filePath, value) {
   await writeTextFileAtomic(filePath, stableJsonString(value));
 }
 async function writeTextFileAtomic(filePath, value) {
-  await ensureDirectory(path6.dirname(filePath));
+  await ensureDirectory(path7.dirname(filePath));
   const temporaryPath = `${filePath}.${randomUUID()}.tmp`;
   await writeFile(temporaryPath, value, "utf8");
   await rename(temporaryPath, filePath);
@@ -135,7 +133,7 @@ async function writeJsonFileExclusive(filePath, value) {
   await writeTextFileExclusive(filePath, stableJsonString(value));
 }
 async function writeTextFileExclusive(filePath, value) {
-  await ensureDirectory(path6.dirname(filePath));
+  await ensureDirectory(path7.dirname(filePath));
   const handle = await open(filePath, "wx");
   try {
     await handle.writeFile(value, "utf8");
@@ -144,7 +142,7 @@ async function writeTextFileExclusive(filePath, value) {
   }
 }
 async function writeBufferIfMissing(filePath, value) {
-  await ensureDirectory(path6.dirname(filePath));
+  await ensureDirectory(path7.dirname(filePath));
   try {
     const handle = await open(filePath, "wx");
     try {
@@ -178,7 +176,7 @@ function isAlreadyExistsError(error) {
   return error?.code === "EEXIST";
 }
 async function withFilesystemLock(lockPath, task) {
-  await ensureDirectory(path6.dirname(lockPath));
+  await ensureDirectory(path7.dirname(lockPath));
   let attempt = 0;
   while (true) {
     try {
@@ -190,7 +188,7 @@ async function withFilesystemLock(lockPath, task) {
       }
       const delayMs = LOCK_RETRY_DELAYS_MS[Math.min(attempt, LOCK_RETRY_DELAYS_MS.length - 1)];
       attempt += 1;
-      await new Promise((resolve5) => setTimeout(resolve5, delayMs));
+      await new Promise((resolve4) => setTimeout(resolve4, delayMs));
     }
   }
   try {
@@ -233,8 +231,8 @@ async function readStructuredPayload(objectPath) {
 var FilesystemArtifactStore = class {
   constructor(rootPath) {
     this.rootPath = rootPath;
-    this.manifestsDirectory = path6.join(this.rootPath, "artifacts", "manifests");
-    this.objectsDirectory = path6.join(this.rootPath, "artifacts", "objects", "sha256");
+    this.manifestsDirectory = path7.join(this.rootPath, "artifacts", "manifests");
+    this.objectsDirectory = path7.join(this.rootPath, "artifacts", "objects", "sha256");
   }
   manifestsDirectory;
   objectsDirectory;
@@ -459,7 +457,7 @@ var FilesystemArtifactStore = class {
     }
   }
   manifestPath(artifactId) {
-    return path6.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
+    return path7.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
   }
 };
 function createArtifactStore(rootPath) {
@@ -487,6 +485,556 @@ function mediaTypeExtension(mediaType) {
   }
 }
 
+// ../protocol/src/dom-action-bridge.ts
+var OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@opensteer/dom-action-bridge");
+function isDomActionBridgeFactory(value) {
+  return typeof value === "function";
+}
+function resolveDomActionBridge(engine) {
+  const candidate = Reflect.get(engine, OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL);
+  return isDomActionBridgeFactory(candidate) ? candidate.call(engine) : void 0;
+}
+
+// ../runtime-core/src/observation-utils.ts
+var REDACTED = "[REDACTED]";
+var SENSITIVE_KEY_PATTERN = /(authorization|proxy[_-]?authorization|cookie|set-cookie|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|token|secret|password|passwd|private[_-]?key|database[_-]?url|db[_-]?url|session(?:id)?|csrf(?:token)?)/i;
+var SENSITIVE_VALUE_PATTERNS = [
+  /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+  /\bAIza[0-9A-Za-z_-]{20,}\b/g,
+  /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g,
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+  /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}\b/gi
+];
+function normalizeObservationContext(context) {
+  if (context === void 0) {
+    return void 0;
+  }
+  const normalized = {
+    ...context.sessionRef === void 0 ? {} : { sessionRef: context.sessionRef },
+    ...context.pageRef === void 0 ? {} : { pageRef: context.pageRef },
+    ...context.frameRef === void 0 ? {} : { frameRef: context.frameRef },
+    ...context.documentRef === void 0 ? {} : { documentRef: context.documentRef },
+    ...context.documentEpoch === void 0 ? {} : { documentEpoch: context.documentEpoch }
+  };
+  return Object.keys(normalized).length === 0 ? void 0 : normalized;
+}
+function createObservationRedactor(config) {
+  const state = createRedactionState(config);
+  return {
+    redactText(value) {
+      return redactString(value, state);
+    },
+    redactJson(value) {
+      return value === void 0 ? void 0 : redactUnknown(value, state, /* @__PURE__ */ new WeakSet());
+    },
+    redactError(error) {
+      if (error === void 0) {
+        return void 0;
+      }
+      return {
+        ...error.code === void 0 ? {} : { code: redactString(error.code, state) },
+        message: redactString(error.message, state),
+        ...error.retriable === void 0 ? {} : { retriable: error.retriable },
+        ...error.details === void 0 ? {} : { details: toCanonicalJsonValue(redactUnknown(error.details, state, /* @__PURE__ */ new WeakSet())) }
+      };
+    },
+    redactLabels(labels) {
+      if (labels === void 0) {
+        return void 0;
+      }
+      const next = Object.entries(labels).reduce(
+        (accumulator, [key, value]) => {
+          accumulator[key] = isSensitiveKey(key, state) ? REDACTED : redactString(value, state);
+          return accumulator;
+        },
+        {}
+      );
+      return Object.keys(next).length === 0 ? void 0 : next;
+    },
+    redactTraceContext(traceContext) {
+      if (traceContext === void 0) {
+        return void 0;
+      }
+      const next = {
+        ...traceContext.traceparent === void 0 ? {} : { traceparent: redactString(traceContext.traceparent, state) },
+        ...traceContext.baggage === void 0 ? {} : { baggage: redactString(traceContext.baggage, state) }
+      };
+      return Object.keys(next).length === 0 ? void 0 : next;
+    }
+  };
+}
+function createRedactionState(config) {
+  return {
+    sensitiveKeys: new Set(
+      (config?.redaction?.sensitiveKeys ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0)
+    ),
+    sensitiveValues: [
+      ...new Set(
+        (config?.redaction?.sensitiveValues ?? []).map((value) => value.trim()).filter((value) => value.length > 0)
+      )
+    ]
+  };
+}
+function redactUnknown(value, state, seen) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return redactString(value, state);
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (seen.has(value)) {
+    return REDACTED;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactUnknown(entry, state, seen));
+  }
+  const next = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    next[key] = isSensitiveKey(key, state) ? REDACTED : redactUnknown(nestedValue, state, seen);
+  }
+  return next;
+}
+function redactString(value, state) {
+  let next = value;
+  for (const secret of state.sensitiveValues) {
+    next = next.split(secret).join(REDACTED);
+  }
+  for (const pattern of SENSITIVE_VALUE_PATTERNS) {
+    next = next.replace(pattern, REDACTED);
+  }
+  return redactUrlString(next, state);
+}
+function redactUrlString(value, state) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return value;
+  }
+  let changed = false;
+  if (parsed.username) {
+    parsed.username = REDACTED;
+    changed = true;
+  }
+  if (parsed.password) {
+    parsed.password = REDACTED;
+    changed = true;
+  }
+  for (const [key] of parsed.searchParams) {
+    if (!isSensitiveKey(key, state)) {
+      continue;
+    }
+    parsed.searchParams.set(key, REDACTED);
+    changed = true;
+  }
+  return changed ? parsed.toString() : value;
+}
+function isSensitiveKey(key, state) {
+  return state.sensitiveKeys.has(key.trim().toLowerCase()) || SENSITIVE_KEY_PATTERN.test(key);
+}
+
+// ../runtime-core/src/observations.ts
+function normalizeObservabilityConfig(input) {
+  const profile = input?.profile ?? "diagnostic";
+  const labels = input?.labels === void 0 ? void 0 : Object.entries(input.labels).reduce((accumulator, [key, value]) => {
+    const normalizedKey = key.trim();
+    const normalizedValue = value.trim();
+    if (normalizedKey.length === 0 || normalizedValue.length === 0) {
+      return accumulator;
+    }
+    if (Object.keys(accumulator).length >= 20) {
+      return accumulator;
+    }
+    accumulator[normalizedKey] = normalizedValue;
+    return accumulator;
+  }, {});
+  const redaction = input?.redaction === void 0 ? void 0 : {
+    ...input.redaction.sensitiveKeys === void 0 ? {} : {
+      sensitiveKeys: input.redaction.sensitiveKeys.map((value) => value.trim()).filter((value) => value.length > 0)
+    },
+    ...input.redaction.sensitiveValues === void 0 ? {} : {
+      sensitiveValues: input.redaction.sensitiveValues.map((value) => value.trim()).filter((value) => value.length > 0)
+    }
+  };
+  return {
+    profile,
+    ...labels === void 0 || Object.keys(labels).length === 0 ? {} : { labels },
+    ...input?.traceContext === void 0 ? {} : {
+      traceContext: {
+        ...input.traceContext.traceparent === void 0 ? {} : { traceparent: input.traceContext.traceparent.trim() },
+        ...input.traceContext.baggage === void 0 ? {} : { baggage: input.traceContext.baggage.trim() }
+      }
+    },
+    ...redaction === void 0 ? {} : { redaction }
+  };
+}
+function eventFileName(sequence) {
+  return `${String(sequence).padStart(12, "0")}.json`;
+}
+var FilesystemSessionSink = class {
+  constructor(store, sessionId) {
+    this.store = store;
+    this.sessionId = sessionId;
+  }
+  append(input) {
+    return this.store.appendEvent(this.sessionId, input);
+  }
+  appendBatch(input) {
+    return this.store.appendEvents(this.sessionId, input);
+  }
+  writeArtifact(input) {
+    return this.store.writeArtifact(this.sessionId, input);
+  }
+  async flush() {
+  }
+  close(reason) {
+    return this.store.closeSession(this.sessionId, reason);
+  }
+};
+var FilesystemObservationStoreImpl = class {
+  constructor(rootPath, artifacts) {
+    this.rootPath = rootPath;
+    this.artifacts = artifacts;
+    this.sessionsDirectory = path7.join(this.rootPath, "observations", "sessions");
+  }
+  sessionsDirectory;
+  redactors = /* @__PURE__ */ new Map();
+  async initialize() {
+    await ensureDirectory(this.sessionsDirectory);
+  }
+  async openSession(input) {
+    const sessionId = normalizeNonEmptyString("sessionId", input.sessionId);
+    const openedAt = normalizeTimestamp("openedAt", input.openedAt ?? Date.now());
+    const config = normalizeObservabilityConfig(input.config);
+    const redactor = createObservationRedactor(config);
+    this.redactors.set(sessionId, redactor);
+    const redactedLabels = redactor.redactLabels(config.labels);
+    const redactedTraceContext = redactor.redactTraceContext(config.traceContext);
+    await withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const existing = await this.reconcileSessionManifest(sessionId);
+      if (existing === void 0) {
+        await ensureDirectory(this.sessionEventsDirectory(sessionId));
+        await ensureDirectory(this.sessionArtifactsDirectory(sessionId));
+        const session = {
+          sessionId,
+          profile: config.profile,
+          ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
+          ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
+          openedAt,
+          updatedAt: openedAt,
+          currentSequence: 0,
+          eventCount: 0,
+          artifactCount: 0
+        };
+        await writeJsonFileExclusive(this.sessionManifestPath(sessionId), session);
+        return;
+      }
+      const patched = {
+        ...existing,
+        profile: config.profile,
+        ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
+        ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
+        updatedAt: Math.max(existing.updatedAt, openedAt)
+      };
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), patched);
+    });
+    return new FilesystemSessionSink(this, sessionId);
+  }
+  async getSession(sessionId) {
+    const manifestPath = this.sessionManifestPath(sessionId);
+    if (!await pathExists(manifestPath)) {
+      return void 0;
+    }
+    return readJsonFile(manifestPath);
+  }
+  async appendEvent(sessionId, input) {
+    const [event] = await this.appendEvents(sessionId, [input]);
+    if (event === void 0) {
+      throw new Error(`failed to append observation event for session ${sessionId}`);
+    }
+    return event;
+  }
+  async appendEvents(sessionId, input) {
+    if (input.length === 0) {
+      return [];
+    }
+    return withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0) {
+        throw new Error(`observation session ${sessionId} was not found`);
+      }
+      const redactor = this.redactors.get(sessionId) ?? createObservationRedactor(void 0);
+      const events = [];
+      let sequence = session.currentSequence;
+      let updatedAt = session.updatedAt;
+      for (const raw of input) {
+        sequence += 1;
+        const createdAt = normalizeTimestamp("createdAt", raw.createdAt);
+        const context = normalizeObservationContext(raw.context);
+        const redactedData = raw.data === void 0 ? void 0 : redactor.redactJson(toCanonicalJsonValue(raw.data));
+        const redactedError = redactor.redactError(raw.error);
+        const event = {
+          eventId: normalizeNonEmptyString(
+            "eventId",
+            raw.eventId ?? `observation:${sessionId}:${String(sequence).padStart(12, "0")}`
+          ),
+          sessionId,
+          sequence,
+          kind: raw.kind,
+          phase: raw.phase,
+          createdAt,
+          correlationId: normalizeNonEmptyString("correlationId", raw.correlationId),
+          ...raw.spanId === void 0 ? {} : { spanId: normalizeNonEmptyString("spanId", raw.spanId) },
+          ...raw.parentSpanId === void 0 ? {} : { parentSpanId: normalizeNonEmptyString("parentSpanId", raw.parentSpanId) },
+          ...context === void 0 ? {} : { context },
+          ...redactedData === void 0 ? {} : { data: redactedData },
+          ...redactedError === void 0 ? {} : { error: redactedError },
+          ...raw.artifactIds === void 0 || raw.artifactIds.length === 0 ? {} : { artifactIds: [...raw.artifactIds] }
+        };
+        await writeJsonFileExclusive(
+          path7.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
+          event
+        );
+        updatedAt = Math.max(updatedAt, createdAt);
+        events.push(event);
+      }
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+        ...session,
+        currentSequence: sequence,
+        eventCount: session.eventCount + events.length,
+        updatedAt
+      });
+      return events;
+    });
+  }
+  async writeArtifact(sessionId, input) {
+    return withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0) {
+        throw new Error(`observation session ${sessionId} was not found`);
+      }
+      const redactor = this.redactors.get(sessionId) ?? createObservationRedactor(void 0);
+      const createdAt = normalizeTimestamp("createdAt", input.createdAt);
+      const context = normalizeObservationContext(input.context);
+      const redactedStorageKey = input.storageKey === void 0 ? void 0 : redactor.redactText(input.storageKey);
+      const redactedMetadata = input.metadata === void 0 ? void 0 : redactor.redactJson(toCanonicalJsonValue(input.metadata));
+      const artifact = {
+        artifactId: normalizeNonEmptyString("artifactId", input.artifactId),
+        sessionId,
+        kind: input.kind,
+        createdAt,
+        ...context === void 0 ? {} : { context },
+        ...input.mediaType === void 0 ? {} : { mediaType: input.mediaType },
+        ...input.byteLength === void 0 ? {} : { byteLength: input.byteLength },
+        ...input.sha256 === void 0 ? {} : { sha256: input.sha256 },
+        ...input.opensteerArtifactId === void 0 ? {} : { opensteerArtifactId: input.opensteerArtifactId },
+        ...redactedStorageKey === void 0 ? {} : { storageKey: redactedStorageKey },
+        ...redactedMetadata === void 0 ? {} : { metadata: redactedMetadata }
+      };
+      const artifactPath = this.sessionArtifactPath(sessionId, artifact.artifactId);
+      if (!await pathExists(artifactPath)) {
+        await writeJsonFileExclusive(artifactPath, artifact);
+        await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+          ...session,
+          artifactCount: session.artifactCount + 1,
+          updatedAt: Math.max(session.updatedAt, createdAt)
+        });
+      }
+      return artifact;
+    });
+  }
+  async listEvents(sessionId, input = {}) {
+    const directoryPath = this.sessionEventsDirectory(sessionId);
+    if (!await pathExists(directoryPath)) {
+      return [];
+    }
+    const files = await listJsonFiles(directoryPath);
+    const events = await Promise.all(
+      files.map((fileName) => readJsonFile(path7.join(directoryPath, fileName)))
+    );
+    const filtered = events.filter((event) => {
+      if (input.kind !== void 0 && event.kind !== input.kind) return false;
+      if (input.phase !== void 0 && event.phase !== input.phase) return false;
+      if (input.correlationId !== void 0 && event.correlationId !== input.correlationId) {
+        return false;
+      }
+      if (input.pageRef !== void 0 && event.context?.pageRef !== input.pageRef) return false;
+      if (input.afterSequence !== void 0 && event.sequence <= input.afterSequence) return false;
+      if (input.from !== void 0 && event.createdAt < input.from) return false;
+      if (input.to !== void 0 && event.createdAt > input.to) return false;
+      return true;
+    });
+    if (input.limit === void 0 || filtered.length <= input.limit) {
+      return filtered;
+    }
+    return filtered.slice(-input.limit);
+  }
+  async listArtifacts(sessionId, input = {}) {
+    const directoryPath = this.sessionArtifactsDirectory(sessionId);
+    if (!await pathExists(directoryPath)) {
+      return [];
+    }
+    const files = await listJsonFiles(directoryPath);
+    const artifacts = await Promise.all(
+      files.map(
+        (fileName) => readJsonFile(path7.join(directoryPath, fileName))
+      )
+    );
+    const filtered = artifacts.filter((artifact) => {
+      if (input.kind !== void 0 && artifact.kind !== input.kind) return false;
+      if (input.pageRef !== void 0 && artifact.context?.pageRef !== input.pageRef) return false;
+      return true;
+    });
+    if (input.limit === void 0 || filtered.length <= input.limit) {
+      return filtered;
+    }
+    return filtered.slice(-input.limit);
+  }
+  async getArtifact(sessionId, artifactId) {
+    const artifactPath = this.sessionArtifactPath(sessionId, artifactId);
+    if (!await pathExists(artifactPath)) {
+      return void 0;
+    }
+    return readJsonFile(artifactPath);
+  }
+  async closeSession(sessionId, _reason) {
+    await withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0 || session.closedAt !== void 0) {
+        return;
+      }
+      const now = Date.now();
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+        ...session,
+        updatedAt: Math.max(session.updatedAt, now),
+        closedAt: now
+      });
+    });
+    this.redactors.delete(sessionId);
+  }
+  async writeArtifactFromManifest(sessionId, manifest, kind, metadata) {
+    return this.writeArtifact(sessionId, {
+      artifactId: manifest.artifactId,
+      kind,
+      createdAt: manifest.createdAt,
+      context: manifest.scope,
+      mediaType: manifest.mediaType,
+      byteLength: manifest.byteLength,
+      sha256: manifest.sha256,
+      opensteerArtifactId: manifest.artifactId,
+      storageKey: manifestToExternalBinaryLocation(this.rootPath, manifest).uri,
+      ...metadata === void 0 ? {} : { metadata }
+    });
+  }
+  async ensureArtifactLinked(sessionId, manifest) {
+    const existing = await this.getArtifact(sessionId, manifest.artifactId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const kind = toObservationArtifactKind(manifest.kind);
+    return this.writeArtifactFromManifest(sessionId, manifest, kind);
+  }
+  async hydrateArtifactManifests(artifactIds) {
+    return (await Promise.all(
+      artifactIds.map(async (artifactId) => this.artifacts.getManifest(artifactId))
+    )).filter((value) => value !== void 0);
+  }
+  sessionDirectory(sessionId) {
+    return path7.join(this.sessionsDirectory, encodePathSegment(sessionId));
+  }
+  sessionManifestPath(sessionId) {
+    return path7.join(this.sessionDirectory(sessionId), "session.json");
+  }
+  sessionEventsDirectory(sessionId) {
+    return path7.join(this.sessionDirectory(sessionId), "events");
+  }
+  sessionArtifactsDirectory(sessionId) {
+    return path7.join(this.sessionDirectory(sessionId), "artifacts");
+  }
+  sessionArtifactPath(sessionId, artifactId) {
+    return path7.join(
+      this.sessionArtifactsDirectory(sessionId),
+      `${encodePathSegment(artifactId)}.json`
+    );
+  }
+  sessionLockPath(sessionId) {
+    return path7.join(this.sessionDirectory(sessionId), ".lock");
+  }
+  async reconcileSessionManifest(sessionId) {
+    const session = await this.getSession(sessionId);
+    if (session === void 0) {
+      return void 0;
+    }
+    const [hasEventDirectory, hasArtifactDirectory] = await Promise.all([
+      pathExists(this.sessionEventsDirectory(sessionId)),
+      pathExists(this.sessionArtifactsDirectory(sessionId))
+    ]);
+    const [eventFiles, artifactFiles] = await Promise.all([
+      hasEventDirectory ? listJsonFiles(this.sessionEventsDirectory(sessionId)) : Promise.resolve([]),
+      hasArtifactDirectory ? listJsonFiles(this.sessionArtifactsDirectory(sessionId)) : Promise.resolve([])
+    ]);
+    const currentSequence = eventFiles.reduce((maxSequence, fileName) => {
+      const parsed = Number.parseInt(fileName.replace(/\.json$/u, ""), 10);
+      return Number.isFinite(parsed) ? Math.max(maxSequence, parsed) : maxSequence;
+    }, 0);
+    const eventCount = eventFiles.length;
+    const artifactCount = artifactFiles.length;
+    if (session.currentSequence === currentSequence && session.eventCount === eventCount && session.artifactCount === artifactCount) {
+      return session;
+    }
+    const [events, artifacts] = await Promise.all([
+      Promise.all(
+        eventFiles.map(
+          (fileName) => readJsonFile(
+            path7.join(this.sessionEventsDirectory(sessionId), fileName)
+          )
+        )
+      ),
+      Promise.all(
+        artifactFiles.map(
+          (fileName) => readJsonFile(
+            path7.join(this.sessionArtifactsDirectory(sessionId), fileName)
+          )
+        )
+      )
+    ]);
+    const updatedAt = Math.max(
+      session.openedAt,
+      session.closedAt ?? 0,
+      ...events.map((event) => event.createdAt),
+      ...artifacts.map((artifact) => artifact.createdAt)
+    );
+    const reconciled = {
+      ...session,
+      currentSequence,
+      eventCount,
+      artifactCount,
+      updatedAt
+    };
+    await writeJsonFileAtomic(this.sessionManifestPath(sessionId), reconciled);
+    return reconciled;
+  }
+};
+function toObservationArtifactKind(kind) {
+  switch (kind) {
+    case "screenshot":
+      return "screenshot";
+    case "dom-snapshot":
+      return "dom-snapshot";
+    case "html-snapshot":
+      return "html-snapshot";
+    default:
+      return "other";
+  }
+}
+function createObservationStore(rootPath, artifacts) {
+  return new FilesystemObservationStoreImpl(rootPath, artifacts);
+}
+
 // ../protocol/src/json.ts
 var JSON_SCHEMA_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
 function defineSchema(schema) {
@@ -554,31 +1102,31 @@ function oneOfSchema(members, options = {}) {
 }
 
 // ../protocol/src/validation.ts
-function validateJsonSchema(schema, value, path13 = "$") {
-  return validateSchemaNode(schema, value, path13);
+function validateJsonSchema(schema, value, path15 = "$") {
+  return validateSchemaNode(schema, value, path15);
 }
-function validateSchemaNode(schema, value, path13) {
+function validateSchemaNode(schema, value, path15) {
   const issues = [];
   if ("const" in schema && !isJsonValueEqual(schema.const, value)) {
     issues.push({
-      path: path13,
+      path: path15,
       message: `must equal ${JSON.stringify(schema.const)}`
     });
     return issues;
   }
   if (schema.enum !== void 0 && !schema.enum.some((candidate) => isJsonValueEqual(candidate, value))) {
     issues.push({
-      path: path13,
+      path: path15,
       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, path13));
+    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path15));
     const validBranches = branchIssues.filter((current) => current.length === 0).length;
     if (validBranches !== 1) {
       issues.push({
-        path: path13,
+        path: path15,
         message: validBranches === 0 ? "must match exactly one supported shape" : "matches multiple supported shapes"
       });
       return issues;
@@ -586,11 +1134,11 @@ function validateSchemaNode(schema, value, path13) {
   }
   if (schema.anyOf !== void 0) {
     const hasMatch = schema.anyOf.some(
-      (member) => validateSchemaNode(member, value, path13).length === 0
+      (member) => validateSchemaNode(member, value, path15).length === 0
     );
     if (!hasMatch) {
       issues.push({
-        path: path13,
+        path: path15,
         message: "must match at least one supported shape"
       });
       return issues;
@@ -598,7 +1146,7 @@ function validateSchemaNode(schema, value, path13) {
   }
   if (schema.allOf !== void 0) {
     for (const member of schema.allOf) {
-      issues.push(...validateSchemaNode(member, value, path13));
+      issues.push(...validateSchemaNode(member, value, path15));
     }
     if (issues.length > 0) {
       return issues;
@@ -606,7 +1154,7 @@ function validateSchemaNode(schema, value, path13) {
   }
   if (schema.type !== void 0 && !matchesSchemaType(schema.type, value)) {
     issues.push({
-      path: path13,
+      path: path15,
       message: `must be ${describeSchemaType(schema.type)}`
     });
     return issues;
@@ -614,19 +1162,19 @@ function validateSchemaNode(schema, value, path13) {
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must have length >= ${String(schema.minLength)}`
       });
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must have length <= ${String(schema.maxLength)}`
       });
     }
     if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must match pattern ${schema.pattern}`
       });
     }
@@ -635,25 +1183,25 @@ function validateSchemaNode(schema, value, path13) {
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must be >= ${String(schema.minimum)}`
       });
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must be <= ${String(schema.maximum)}`
       });
     }
     if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must be > ${String(schema.exclusiveMinimum)}`
       });
     }
     if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must be < ${String(schema.exclusiveMaximum)}`
       });
     }
@@ -662,13 +1210,13 @@ function validateSchemaNode(schema, value, path13) {
   if (Array.isArray(value)) {
     if (schema.minItems !== void 0 && value.length < schema.minItems) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must have at least ${String(schema.minItems)} items`
       });
     }
     if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must have at most ${String(schema.maxItems)} items`
       });
     }
@@ -678,7 +1226,7 @@ function validateSchemaNode(schema, value, path13) {
         const key = JSON.stringify(item);
         if (seen.has(key)) {
           issues.push({
-            path: path13,
+            path: path15,
             message: "must not contain duplicate items"
           });
           break;
@@ -688,7 +1236,7 @@ function validateSchemaNode(schema, value, path13) {
     }
     if (schema.items !== void 0) {
       for (let index = 0; index < value.length; index += 1) {
-        issues.push(...validateSchemaNode(schema.items, value[index], `${path13}[${String(index)}]`));
+        issues.push(...validateSchemaNode(schema.items, value[index], `${path15}[${String(index)}]`));
       }
     }
     return issues;
@@ -698,7 +1246,7 @@ function validateSchemaNode(schema, value, path13) {
     for (const requiredKey of schema.required ?? []) {
       if (!(requiredKey in value)) {
         issues.push({
-          path: joinObjectPath(path13, requiredKey),
+          path: joinObjectPath(path15, requiredKey),
           message: "is required"
         });
       }
@@ -707,13 +1255,13 @@ function validateSchemaNode(schema, value, path13) {
       const propertySchema = properties[key];
       if (propertySchema !== void 0) {
         issues.push(
-          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path13, key))
+          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path15, key))
         );
         continue;
       }
       if (schema.additionalProperties === false) {
         issues.push({
-          path: joinObjectPath(path13, key),
+          path: joinObjectPath(path15, key),
           message: "is not allowed"
         });
         continue;
@@ -723,7 +1271,7 @@ function validateSchemaNode(schema, value, path13) {
           ...validateSchemaNode(
             schema.additionalProperties,
             propertyValue,
-            joinObjectPath(path13, key)
+            joinObjectPath(path15, key)
           )
         );
       }
@@ -967,8 +1515,8 @@ function matchesNetworkRecordFilters(record, filters) {
     }
   }
   if (filters.path !== void 0) {
-    const path13 = getParsedUrl().pathname;
-    if (!includesCaseInsensitive(path13, filters.path)) {
+    const path15 = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path15, filters.path)) {
       return false;
     }
   }
@@ -1442,7 +1990,7 @@ var networkRecordSchema = objectSchema(
 var networkQueryRecordSchema = objectSchema(
   {
     recordId: stringSchema({ minLength: 1 }),
-    actionId: stringSchema({ minLength: 1 }),
+    capture: stringSchema({ minLength: 1 }),
     tags: arraySchema(stringSchema({ minLength: 1 }), {
       uniqueItems: true
     }),
@@ -1922,8 +2470,7 @@ var opensteerRecipeStepSchema = oneOfSchema(
     objectSchema(
       {
         kind: enumSchema(["goto"]),
-        url: stringSchema({ minLength: 1 }),
-        networkTag: stringSchema({ minLength: 1 })
+        url: stringSchema({ minLength: 1 })
       },
       {
         title: "OpensteerAuthRecipeGotoStep",
@@ -1932,8 +2479,7 @@ var opensteerRecipeStepSchema = oneOfSchema(
     ),
     objectSchema(
       {
-        kind: enumSchema(["reload"]),
-        networkTag: stringSchema({ minLength: 1 })
+        kind: enumSchema(["reload"])
       },
       {
         title: "OpensteerAuthRecipeReloadStep",
@@ -2150,7 +2696,7 @@ var opensteerNetworkQueryInputSchema = objectSchema(
     pageRef: pageRefSchema,
     recordId: stringSchema({ minLength: 1 }),
     requestId: stringSchema({ minLength: 1 }),
-    actionId: stringSchema({ minLength: 1 }),
+    capture: stringSchema({ minLength: 1 }),
     tag: stringSchema({ minLength: 1 }),
     url: stringSchema({ minLength: 1 }),
     hostname: stringSchema({ minLength: 1 }),
@@ -2179,7 +2725,7 @@ var opensteerNetworkTagInputSchema = objectSchema(
     pageRef: pageRefSchema,
     recordId: stringSchema({ minLength: 1 }),
     requestId: stringSchema({ minLength: 1 }),
-    actionId: stringSchema({ minLength: 1 }),
+    capture: stringSchema({ minLength: 1 }),
     tag: stringSchema({ minLength: 1 }),
     url: stringSchema({ minLength: 1 }),
     hostname: stringSchema({ minLength: 1 }),
@@ -2204,6 +2750,7 @@ var opensteerNetworkTagOutputSchema = objectSchema(
 );
 var opensteerNetworkClearInputSchema = objectSchema(
   {
+    capture: stringSchema({ minLength: 1 }),
     tag: stringSchema({ minLength: 1 })
   },
   {
@@ -6055,7 +6602,7 @@ var opensteerPageCloseOutputSchema = objectSchema(
 var opensteerPageGotoInputSchema = objectSchema(
   {
     url: stringSchema(),
-    networkTag: stringSchema({ minLength: 1 })
+    captureNetwork: stringSchema({ minLength: 1 })
   },
   {
     title: "OpensteerPageGotoInput",
@@ -6206,7 +6753,7 @@ var opensteerDomClickInputSchema = objectSchema(
   {
     target: opensteerTargetInputSchema,
     persistAsDescription: stringSchema(),
-    networkTag: stringSchema({ minLength: 1 })
+    captureNetwork: stringSchema({ minLength: 1 })
   },
   {
     title: "OpensteerDomClickInput",
@@ -6217,7 +6764,7 @@ var opensteerDomHoverInputSchema = objectSchema(
   {
     target: opensteerTargetInputSchema,
     persistAsDescription: stringSchema(),
-    networkTag: stringSchema({ minLength: 1 })
+    captureNetwork: stringSchema({ minLength: 1 })
   },
   {
     title: "OpensteerDomHoverInput",
@@ -6230,7 +6777,7 @@ var opensteerDomInputInputSchema = objectSchema(
     text: stringSchema(),
     pressEnter: { type: "boolean" },
     persistAsDescription: stringSchema(),
-    networkTag: stringSchema({ minLength: 1 })
+    captureNetwork: stringSchema({ minLength: 1 })
   },
   {
     title: "OpensteerDomInputInput",
@@ -6243,7 +6790,7 @@ var opensteerDomScrollInputSchema = objectSchema(
     direction: enumSchema(["up", "down", "left", "right"]),
     amount: integerSchema({ minimum: 1 }),
     persistAsDescription: stringSchema(),
-    networkTag: stringSchema({ minLength: 1 })
+    captureNetwork: stringSchema({ minLength: 1 })
   },
   {
     title: "OpensteerDomScrollInput",
@@ -6444,7 +6991,7 @@ var opensteerComputerExecuteInputSchema = objectSchema(
   {
     action: opensteerComputerActionSchema,
     screenshot: opensteerComputerScreenshotOptionsSchema,
-    networkTag: stringSchema({ minLength: 1 })
+    captureNetwork: stringSchema({ minLength: 1 })
   },
   {
     title: "OpensteerComputerExecuteInput",
@@ -7049,9 +7596,9 @@ function compareByCreatedAtAndId(left, right) {
 var FilesystemRegistryStore = class {
   constructor(rootPath, registryRelativePath) {
     this.registryRelativePath = registryRelativePath;
-    const basePath = path6.join(rootPath, ...registryRelativePath);
-    this.recordsDirectory = path6.join(basePath, "records");
-    this.indexesDirectory = path6.join(basePath, "indexes", "by-key");
+    const basePath = path7.join(rootPath, ...registryRelativePath);
+    this.recordsDirectory = path7.join(basePath, "records");
+    this.indexesDirectory = path7.join(basePath, "indexes", "by-key");
   }
   recordsDirectory;
   indexesDirectory;
@@ -7120,7 +7667,7 @@ var FilesystemRegistryStore = class {
   async readRecordsFromDirectory() {
     const files = await listJsonFiles(this.recordsDirectory);
     const records = await Promise.all(
-      files.map((fileName) => readJsonFile(path6.join(this.recordsDirectory, fileName)))
+      files.map((fileName) => readJsonFile(path7.join(this.recordsDirectory, fileName)))
     );
     records.sort(compareByCreatedAtAndId);
     return records;
@@ -7152,17 +7699,17 @@ var FilesystemRegistryStore = class {
     return record;
   }
   recordPath(id) {
-    return path6.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
+    return path7.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
   }
   indexPath(key, version) {
-    return path6.join(
+    return path7.join(
       this.indexesDirectory,
       encodePathSegment(key),
       `${encodePathSegment(version)}.json`
     );
   }
   writeLockPath() {
-    return path6.join(path6.dirname(this.recordsDirectory), ".write.lock");
+    return path7.join(path7.dirname(this.recordsDirectory), ".write.lock");
   }
 };
 var FilesystemDescriptorRegistry = class extends FilesystemRegistryStore {
@@ -7532,7 +8079,7 @@ var SqliteSavedNetworkStore = class {
   directoryInitialization;
   databaseInitialization;
   constructor(rootPath) {
-    this.databasePath = path6.join(rootPath, "registry", "saved-network.sqlite");
+    this.databasePath = path7.join(rootPath, "registry", "saved-network.sqlite");
   }
   async initialize() {
     await this.ensureDatabaseDirectory();
@@ -7570,7 +8117,7 @@ var SqliteSavedNetworkStore = class {
           page_ref_key: pageRefKey,
           frame_ref: entry.record.frameRef ?? null,
           document_ref: entry.record.documentRef ?? null,
-          action_id: entry.actionId ?? null,
+          capture: entry.capture ?? null,
           method: entry.record.method,
           method_lc: entry.record.method.toLowerCase(),
           url: entry.record.url,
@@ -7683,39 +8230,31 @@ var SqliteSavedNetworkStore = class {
   }
   async clear(input = {}) {
     const database = await this.requireDatabase();
-    const countAll = database.prepare(`
-      SELECT COUNT(*) AS cleared
-      FROM saved_network_records
-    `);
-    const countByTag = database.prepare(`
-      SELECT COUNT(DISTINCT record_id) AS cleared
-      FROM saved_network_tags
-      WHERE tag = @tag
-    `);
-    const deleteAllTags = database.prepare(`DELETE FROM saved_network_tags`);
+    const countAll = database.prepare(`SELECT COUNT(*) AS cleared FROM saved_network_records`);
     const deleteAllRecords = database.prepare(`DELETE FROM saved_network_records`);
-    const deleteTag = database.prepare(`
-      DELETE FROM saved_network_tags
-      WHERE tag = @tag
+    const { whereSql, parameters } = buildSavedNetworkWhere(input);
+    const countFiltered = database.prepare(`
+      SELECT COUNT(*) AS cleared
+      FROM saved_network_records r
+      ${whereSql}
     `);
-    const deleteOrphans = database.prepare(`
+    const deleteFiltered = database.prepare(`
       DELETE FROM saved_network_records
-      WHERE NOT EXISTS (
-        SELECT 1
-        FROM saved_network_tags t
-        WHERE t.record_id = saved_network_records.record_id
+      WHERE record_id IN (
+        SELECT r.record_id
+        FROM saved_network_records r
+        ${whereSql}
       )
     `);
     return withSqliteTransaction(database, () => {
-      const tag = input.tag;
-      const cleared = tag === void 0 ? countAll.get().cleared : countByTag.get({ tag }).cleared;
-      if (tag === void 0) {
-        deleteAllTags.run();
+      if (input.capture === void 0 && input.tag === void 0) {
+        const cleared2 = countAll.get().cleared;
         deleteAllRecords.run();
-        return cleared;
+        return cleared2;
       }
-      deleteTag.run({ tag });
-      deleteOrphans.run();
+      const args = parameters;
+      const cleared = countFiltered.get(...args).cleared;
+      deleteFiltered.run(...args);
       return cleared;
     });
   }
@@ -7750,7 +8289,7 @@ var SqliteSavedNetworkStore = class {
     }
   }
   async ensureDatabaseDirectory() {
-    this.directoryInitialization ??= ensureDirectory(path6.dirname(this.databasePath)).catch(
+    this.directoryInitialization ??= ensureDirectory(path7.dirname(this.databasePath)).catch(
       (error) => {
         this.directoryInitialization = void 0;
         throw error;
@@ -7770,7 +8309,7 @@ var SqliteSavedNetworkStore = class {
         page_ref_key TEXT NOT NULL,
         frame_ref TEXT,
         document_ref TEXT,
-        action_id TEXT,
+        capture TEXT,
         method TEXT NOT NULL,
         method_lc TEXT NOT NULL,
         url TEXT NOT NULL,
@@ -7809,6 +8348,9 @@ var SqliteSavedNetworkStore = class {
       CREATE INDEX IF NOT EXISTS saved_network_records_saved_at
         ON saved_network_records (saved_at DESC);
 
+      CREATE INDEX IF NOT EXISTS saved_network_records_capture
+        ON saved_network_records (capture);
+
       CREATE TABLE IF NOT EXISTS saved_network_tags (
         record_id TEXT NOT NULL REFERENCES saved_network_records(record_id) ON DELETE CASCADE,
         tag TEXT NOT NULL,
@@ -7824,6 +8366,7 @@ var SqliteSavedNetworkStore = class {
       "capture_state",
       "TEXT NOT NULL DEFAULT 'complete'"
     );
+    this.ensureColumn(database, "saved_network_records", "capture", "TEXT");
     this.ensureColumn(
       database,
       "saved_network_records",
@@ -7864,9 +8407,9 @@ function buildSavedNetworkWhere(input) {
     clauses.push("r.request_id = ?");
     parameters.push(input.requestId);
   }
-  if (input.actionId !== void 0) {
-    clauses.push("r.action_id = ?");
-    parameters.push(input.actionId);
+  if (input.capture !== void 0) {
+    clauses.push("r.capture = ?");
+    parameters.push(input.capture);
   }
   if (input.tag !== void 0) {
     clauses.push(`
@@ -7928,7 +8471,7 @@ function buildSavedNetworkUpsertSql(bodyWriteMode) {
         page_ref_key,
         frame_ref,
         document_ref,
-        action_id,
+        capture,
         method,
         method_lc,
         url,
@@ -7967,7 +8510,7 @@ function buildSavedNetworkUpsertSql(bodyWriteMode) {
         @page_ref_key,
         @frame_ref,
         @document_ref,
-        @action_id,
+        @capture,
         @method,
         @method_lc,
         @url,
@@ -8004,7 +8547,7 @@ function buildSavedNetworkUpsertSql(bodyWriteMode) {
         page_ref_key = excluded.page_ref_key,
         frame_ref = excluded.frame_ref,
         document_ref = excluded.document_ref,
-        action_id = excluded.action_id,
+        capture = excluded.capture,
         method = excluded.method,
         method_lc = excluded.method_lc,
         url = excluded.url,
@@ -8099,7 +8642,7 @@ function inflateSavedNetworkRow(row, includeBodies) {
   }
   return {
     recordId: row.record_id,
-    ...row.action_id === null ? {} : { actionId: row.action_id },
+    ...row.capture === null ? {} : { capture: row.capture },
     ...row.tags === null || row.tags.length === 0 ? {} : { tags: row.tags.split(TAG_DELIMITER).filter((tag) => tag.length > 0) },
     savedAt: row.saved_at,
     record
@@ -8152,7 +8695,7 @@ var FilesystemTraceStore = class {
   constructor(rootPath, artifacts) {
     this.rootPath = rootPath;
     this.artifacts = artifacts;
-    this.runsDirectory = path6.join(this.rootPath, "traces", "runs");
+    this.runsDirectory = path7.join(this.rootPath, "traces", "runs");
   }
   runsDirectory;
   async initialize() {
@@ -8229,7 +8772,7 @@ var FilesystemTraceStore = class {
         ...input.error === void 0 ? {} : { error: input.error }
       };
       await writeJsonFileExclusive(
-        path6.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
+        path7.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
         entry
       );
       await writeJsonFileAtomic(this.runManifestPath(runId), {
@@ -8248,7 +8791,7 @@ var FilesystemTraceStore = class {
     const files = await listJsonFiles(entriesDirectory);
     return Promise.all(
       files.map(
-        (fileName) => readJsonFile(path6.join(entriesDirectory, fileName))
+        (fileName) => readJsonFile(path7.join(entriesDirectory, fileName))
       )
     );
   }
@@ -8294,16 +8837,16 @@ var FilesystemTraceStore = class {
     return { trace, artifacts };
   }
   runDirectory(runId) {
-    return path6.join(this.runsDirectory, encodeURIComponent(runId));
+    return path7.join(this.runsDirectory, encodeURIComponent(runId));
   }
   runEntriesDirectory(runId) {
-    return path6.join(this.runDirectory(runId), "entries");
+    return path7.join(this.runDirectory(runId), "entries");
   }
   runManifestPath(runId) {
-    return path6.join(this.runDirectory(runId), "manifest.json");
+    return path7.join(this.runDirectory(runId), "manifest.json");
   }
   runWriteLockPath(runId) {
-    return path6.join(this.runDirectory(runId), ".append.lock");
+    return path7.join(this.runDirectory(runId), ".append.lock");
   }
 };
 function createTraceStore(rootPath, artifacts) {
@@ -8317,7 +8860,7 @@ function normalizeWorkspaceId(workspace) {
   return encodePathSegment(workspace);
 }
 function resolveFilesystemWorkspacePath(input) {
-  return path6.join(
+  return path7.join(
     input.rootDir,
     ".opensteer",
     "workspaces",
@@ -8326,17 +8869,18 @@ function resolveFilesystemWorkspacePath(input) {
 }
 async function createFilesystemOpensteerWorkspace(options) {
   await ensureDirectory(options.rootPath);
-  const manifestPath = path6.join(options.rootPath, "workspace.json");
-  const browserPath = path6.join(options.rootPath, "browser");
-  const browserManifestPath = path6.join(browserPath, "manifest.json");
-  const browserUserDataDir = path6.join(browserPath, "user-data");
-  const livePath = path6.join(options.rootPath, "live");
-  const liveLocalPath = path6.join(livePath, "local.json");
-  const liveCloudPath = path6.join(livePath, "cloud.json");
-  const artifactsPath = path6.join(options.rootPath, "artifacts");
-  const tracesPath = path6.join(options.rootPath, "traces");
-  const registryPath = path6.join(options.rootPath, "registry");
-  const lockPath = path6.join(options.rootPath, ".lock");
+  const manifestPath = path7.join(options.rootPath, "workspace.json");
+  const browserPath = path7.join(options.rootPath, "browser");
+  const browserManifestPath = path7.join(browserPath, "manifest.json");
+  const browserUserDataDir = path7.join(browserPath, "user-data");
+  const livePath = path7.join(options.rootPath, "live");
+  const liveLocalPath = path7.join(livePath, "local.json");
+  const liveCloudPath = path7.join(livePath, "cloud.json");
+  const artifactsPath = path7.join(options.rootPath, "artifacts");
+  const tracesPath = path7.join(options.rootPath, "traces");
+  const observationsPath = path7.join(options.rootPath, "observations");
+  const registryPath = path7.join(options.rootPath, "registry");
+  const lockPath = path7.join(options.rootPath, ".lock");
   let manifest;
   if (await pathExists(manifestPath)) {
     manifest = await readJsonFile(manifestPath);
@@ -8350,6 +8894,17 @@ async function createFilesystemOpensteerWorkspace(options) {
         `workspace ${options.rootPath} uses unsupported version ${String(manifest.version)}`
       );
     }
+    if (manifest.paths.observations === void 0) {
+      manifest = {
+        ...manifest,
+        updatedAt: Date.now(),
+        paths: {
+          ...manifest.paths,
+          observations: "observations"
+        }
+      };
+      await writeJsonFileAtomic(manifestPath, manifest);
+    }
   } else {
     const createdAt = normalizeTimestamp("createdAt", options.createdAt ?? Date.now());
     manifest = {
@@ -8364,6 +8919,7 @@ async function createFilesystemOpensteerWorkspace(options) {
         live: "live",
         artifacts: "artifacts",
         traces: "traces",
+        observations: "observations",
         registry: "registry"
       }
     };
@@ -8375,6 +8931,7 @@ async function createFilesystemOpensteerWorkspace(options) {
     ensureDirectory(livePath),
     ensureDirectory(artifactsPath),
     ensureDirectory(tracesPath),
+    ensureDirectory(observationsPath),
     ensureDirectory(registryPath)
   ]);
   const artifacts = createArtifactStore(options.rootPath);
@@ -8399,6 +8956,8 @@ async function createFilesystemOpensteerWorkspace(options) {
   await reverseReports.initialize();
   const traces = createTraceStore(options.rootPath, artifacts);
   await traces.initialize();
+  const observations = createObservationStore(options.rootPath, artifacts);
+  await observations.initialize();
   return {
     rootPath: options.rootPath,
     manifestPath,
@@ -8411,10 +8970,12 @@ async function createFilesystemOpensteerWorkspace(options) {
     liveCloudPath,
     artifactsPath,
     tracesPath,
+    observationsPath,
     registryPath,
     lockPath,
     artifacts,
     traces,
+    observations,
     registry: {
       descriptors,
       requestPlans,
@@ -8439,9 +9000,9 @@ var DEFAULT_TIMEOUTS = {
   "page.add-init-script": 1e4,
   "page.snapshot": 15e3,
   "computer.execute": 3e4,
-  "dom.click": 1e4,
+  "dom.click": 3e4,
   "dom.hover": 1e4,
-  "dom.input": 1e4,
+  "dom.input": 3e4,
   "dom.scroll": 1e4,
   "dom.extract": 15e3,
   "network.query": 15e3,
@@ -8601,10 +9162,10 @@ function delayWithSignal(delayMs, signal) {
   if (signal.aborted) {
     return Promise.reject(signal.reason ?? abortError());
   }
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve4, reject) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve5();
+      resolve4();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -9069,9 +9630,9 @@ var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "poster",
   "ping"
 ]);
-function buildArrayFieldPathCandidates(path13) {
-  const strict = path13.nodes.length ? buildPathCandidates(path13.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path13.nodes);
+function buildArrayFieldPathCandidates(path15) {
+  const strict = path15.nodes.length ? buildPathCandidates(path15.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path15.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -9601,18 +10162,18 @@ function cloneStructuralElementAnchor(anchor) {
     nodes: anchor.nodes.map(clonePathNode)
   };
 }
-function cloneReplayElementPath(path13) {
+function cloneReplayElementPath(path15) {
   return {
     resolution: "deterministic",
-    context: cloneContext(path13.context),
-    nodes: path13.nodes.map(clonePathNode)
+    context: cloneContext(path15.context),
+    nodes: path15.nodes.map(clonePathNode)
   };
 }
-function cloneElementPath(path13) {
-  return cloneReplayElementPath(path13);
+function cloneElementPath(path15) {
+  return cloneReplayElementPath(path15);
 }
-function buildPathSelectorHint(path13) {
-  const nodes = path13?.nodes || [];
+function buildPathSelectorHint(path15) {
+  const nodes = path15?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) {
     return "*";
@@ -9661,15 +10222,15 @@ function sanitizeStructuralElementAnchor(anchor) {
     nodes: sanitizeNodes(anchor.nodes)
   };
 }
-function sanitizeReplayElementPath(path13) {
+function sanitizeReplayElementPath(path15) {
   return {
     resolution: "deterministic",
-    context: sanitizeContext(path13.context),
-    nodes: sanitizeNodes(path13.nodes)
+    context: sanitizeContext(path15.context),
+    nodes: sanitizeNodes(path15.nodes)
   };
 }
-function sanitizeElementPath(path13) {
-  return sanitizeReplayElementPath(path13);
+function sanitizeElementPath(path15) {
+  return sanitizeReplayElementPath(path15);
 }
 function buildLocalStructuralElementAnchor(index, rawTargetNode) {
   const targetNode = requireElementNode(index, rawTargetNode);
@@ -9792,8 +10353,8 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
   }
   return `${base} Target depth ${String(depth)}. Candidate counts: ${sample}.`;
 }
-function buildArrayFieldCandidates(path13) {
-  return buildArrayFieldPathCandidates(path13);
+function buildArrayFieldCandidates(path15) {
+  return buildArrayFieldPathCandidates(path15);
 }
 function firstDefinedAttribute(node, keys) {
   for (const key of keys) {
@@ -10236,6 +10797,7 @@ var MemoryDomDescriptorStore = class {
 };
 
 // ../runtime-core/src/action-boundary.ts
+var actionBoundaryDiagnosticsBySignal = /* @__PURE__ */ new WeakMap();
 async function captureActionBoundarySnapshot(engine, pageRef) {
   const frames = await engine.listFrames({ pageRef });
   const mainFrame = frames.find((frame) => frame.isMainFrame);
@@ -10247,6 +10809,35 @@ async function captureActionBoundarySnapshot(engine, pageRef) {
     documentRef: mainFrame.documentRef
   };
 }
+function createActionBoundaryDiagnostics(input) {
+  return {
+    trigger: input.boundary.trigger,
+    crossDocument: input.boundary.crossDocument,
+    bootstrapSettled: input.boundary.bootstrapSettled,
+    visualSettled: input.visualSettled,
+    ...input.boundary.timedOutPhase !== void 0 ? { timedOutPhase: input.boundary.timedOutPhase } : !input.visualSettled ? { timedOutPhase: "visual" } : {}
+  };
+}
+function recordActionBoundaryDiagnostics(signal, diagnostics) {
+  actionBoundaryDiagnosticsBySignal.set(signal, diagnostics);
+}
+function takeActionBoundaryDiagnostics(signal) {
+  const diagnostics = actionBoundaryDiagnosticsBySignal.get(signal);
+  actionBoundaryDiagnosticsBySignal.delete(signal);
+  return diagnostics;
+}
+function isSoftSettleTimeoutError(error, signal) {
+  if (isTimeoutError(error)) {
+    return true;
+  }
+  return signal?.aborted === true && isTimeoutError(signal.reason) && (error === signal.reason || isAbortError(error));
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function isTimeoutError(error) {
+  return isOpensteerProtocolError(error) && error.code === "timeout";
+}
 
 // ../runtime-core/src/runtimes/dom/executor.ts
 var MAX_DOM_ACTION_ATTEMPTS = 3;
@@ -10270,14 +10861,16 @@ var DomActionExecutor = class {
         ...input.timeout === void 0 ? {} : { timeout: input.timeout }
       },
       async (pointerTarget, point, timeout) => {
-        await timeout.runStep(
+        const events = [];
+        const moved = await timeout.runStep(
           () => this.options.engine.mouseMove({
             pageRef: pointerTarget.resolved.pageRef,
             point,
             coordinateSpace: "document-css"
           })
         );
-        await timeout.runStep(
+        events.push(...moved.events);
+        const clicked = await timeout.runStep(
           () => this.options.engine.mouseClick({
             pageRef: pointerTarget.resolved.pageRef,
             point,
@@ -10287,7 +10880,12 @@ var DomActionExecutor = class {
             ...input.modifiers === void 0 ? {} : { modifiers: input.modifiers }
           })
         );
-        return { resolved: pointerTarget.original, point };
+        events.push(...clicked.events);
+        return {
+          resolved: pointerTarget.original,
+          point,
+          ...events.length === 0 ? {} : { events }
+        };
       }
     );
   }
@@ -10301,14 +10899,18 @@ var DomActionExecutor = class {
         ...input.timeout === void 0 ? {} : { timeout: input.timeout }
       },
       async (pointerTarget, point, timeout) => {
-        await timeout.runStep(
+        const moved = await timeout.runStep(
           () => this.options.engine.mouseMove({
             pageRef: pointerTarget.resolved.pageRef,
             point,
             coordinateSpace: "document-css"
           })
         );
-        return { resolved: pointerTarget.original, point };
+        return {
+          resolved: pointerTarget.original,
+          point,
+          ...moved.events.length === 0 ? {} : { events: moved.events }
+        };
       }
     );
   }
@@ -10322,14 +10924,16 @@ var DomActionExecutor = class {
         ...input.timeout === void 0 ? {} : { timeout: input.timeout }
       },
       async (pointerTarget, point, timeout) => {
-        await timeout.runStep(
+        const events = [];
+        const moved = await timeout.runStep(
           () => this.options.engine.mouseMove({
             pageRef: pointerTarget.resolved.pageRef,
             point,
             coordinateSpace: "document-css"
           })
         );
-        await timeout.runStep(
+        events.push(...moved.events);
+        const scrolled = await timeout.runStep(
           () => this.options.engine.mouseScroll({
             pageRef: pointerTarget.resolved.pageRef,
             point,
@@ -10337,7 +10941,12 @@ var DomActionExecutor = class {
             delta: input.delta
           })
         );
-        return { resolved: pointerTarget.original, point };
+        events.push(...scrolled.events);
+        return {
+          resolved: pointerTarget.original,
+          point,
+          ...events.length === 0 ? {} : { events }
+        };
       }
     );
   }
@@ -10379,7 +10988,7 @@ var DomActionExecutor = class {
           let finalResolved = resolved;
           let finalSnapshot;
           if (input.pressEnter) {
-            await this.settle(resolved.pageRef, "dom.input", timeout);
+            await this.waitForPressEnterReaction(timeout);
             const enterSession = this.options.createResolutionSession();
             const enterResolved = await timeout.runStep(
               () => this.options.resolveTarget(enterSession, {
@@ -10403,7 +11012,15 @@ var DomActionExecutor = class {
             );
             finalResolved = enterResolved;
           }
-          await this.settle(finalResolved.pageRef, "dom.input", timeout, finalSnapshot);
+          const settleDiagnostics = await this.settle(
+            finalResolved.pageRef,
+            "dom.input",
+            timeout,
+            finalSnapshot
+          );
+          if (finalSnapshot !== void 0) {
+            recordActionBoundaryDiagnostics(timeout.signal, settleDiagnostics);
+          }
           return finalResolved;
         } catch (error) {
           lastError = error;
@@ -10480,12 +11097,13 @@ var DomActionExecutor = class {
             () => captureActionBoundarySnapshot(this.options.engine, pointerTarget.resolved.pageRef)
           );
           const outcome = await dispatch(pointerTarget, point, timeout);
-          await this.settle(
+          const settleDiagnostics = await this.settle(
             pointerTarget.resolved.pageRef,
             input.operation,
             timeout,
             actionBoundarySnapshot
           );
+          recordActionBoundaryDiagnostics(timeout.signal, settleDiagnostics);
           return outcome;
         } catch (error) {
           lastError = error;
@@ -10505,22 +11123,47 @@ var DomActionExecutor = class {
   }
   async settle(pageRef, operation, timeout, snapshot) {
     const bridge = this.requireBridge();
-    await timeout.runStep(
+    let visualSettled = true;
+    const boundary = await timeout.runStep(
       () => bridge.finalizeDomAction(pageRef, {
         operation,
         ...snapshot === void 0 ? {} : { snapshot },
         signal: timeout.signal,
         remainingMs: () => timeout.remainingMs(),
-        policySettle: (targetPageRef, trigger) => settleWithPolicy(this.options.policy.settle, {
-          operation,
-          trigger,
-          engine: this.options.engine,
-          pageRef: targetPageRef,
-          signal: timeout.signal,
-          remainingMs: timeout.remainingMs()
-        })
+        policySettle: async (targetPageRef, trigger) => {
+          try {
+            await settleWithPolicy(this.options.policy.settle, {
+              operation,
+              trigger,
+              engine: this.options.engine,
+              pageRef: targetPageRef,
+              signal: timeout.signal,
+              remainingMs: timeout.remainingMs()
+            });
+          } catch (error) {
+            if (snapshot !== void 0 && isSoftSettleTimeoutError(error, timeout.signal)) {
+              visualSettled = false;
+              return;
+            }
+            throw error;
+          }
+        }
       })
     );
+    return createActionBoundaryDiagnostics({
+      boundary,
+      visualSettled
+    });
+  }
+  async waitForPressEnterReaction(timeout) {
+    const delayMs = this.options.policy.settle.resolveDelayMs({
+      operation: "dom.input",
+      trigger: "dom-action"
+    });
+    if (delayMs <= 0) {
+      return;
+    }
+    await delayWithSignal(delayMs, timeout.signal);
   }
   requireBridge() {
     if (this.bridge !== void 0) {
@@ -11229,21 +11872,21 @@ var DefaultDomRuntime = class {
     return match;
   }
   async resolvePathTarget(session, pageRef, rawPath, source, description, descriptor) {
-    const path13 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path13.context);
-    const target = resolveDomPathInScope(context.index, path13.nodes, context.scope);
+    const path15 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path15.context);
+    const target = resolveDomPathInScope(context.index, path15.nodes, context.scope);
     if (!target) {
-      throwTargetNotFound(context.index, path13.nodes, context.scope);
+      throwTargetNotFound(context.index, path15.nodes, context.scope);
     }
     if (target.node.nodeRef === void 0) {
       throw new Error(
-        `resolved path "${buildPathSelectorHint(path13)}" does not point to a live element`
+        `resolved path "${buildPathSelectorHint(path15)}" 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: path13,
+      replayPath: path15,
       ...source === "path" || source === "descriptor" ? { selectorUsed: target.selector } : {},
       ...descriptor === void 0 ? {} : { descriptor }
     });
@@ -11264,9 +11907,9 @@ var DefaultDomRuntime = class {
     });
   }
   async queryAllByElementPath(session, pageRef, rawPath) {
-    const path13 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path13.context);
-    return queryAllDomPathInScope(context.index, path13.nodes, context.scope).filter(
+    const path15 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path15.context);
+    return queryAllDomPathInScope(context.index, path15.nodes, context.scope).filter(
       (node) => node.nodeRef !== void 0
     ).map((node) => this.createSnapshotTarget(context.snapshot, node));
   }
@@ -11452,16 +12095,16 @@ var DefaultDomRuntime = class {
     const index = createSnapshotIndex(item.snapshot);
     return this.resolveFirstArrayFieldTargetInNode(index, item.node, field.path);
   }
-  resolveFirstArrayFieldTargetInNode(index, rootNode, path13) {
-    const normalizedPath = sanitizeElementPath(path13);
+  resolveFirstArrayFieldTargetInNode(index, rootNode, path15) {
+    const normalizedPath = sanitizeElementPath(path15);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
     }
     return resolveFirstWithinNodeBySelectors(index, rootNode, selectors);
   }
-  resolveUniqueArrayFieldTargetInNode(index, rootNode, path13) {
-    const normalizedPath = sanitizeElementPath(path13);
+  resolveUniqueArrayFieldTargetInNode(index, rootNode, path15) {
+    const normalizedPath = sanitizeElementPath(path15);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
@@ -11550,8 +12193,8 @@ function encodeDataPath(tokens) {
   }
   return out;
 }
-function parseDataPath(path13) {
-  const input = path13.trim();
+function parseDataPath(path15) {
+  const input = path15.trim();
   if (input.length === 0) {
     return [];
   }
@@ -11601,8 +12244,8 @@ function parseDataPath(path13) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path13, value] of Object.entries(flat)) {
-    const tokens = parseDataPath(path13);
+  for (const [path15, value] of Object.entries(flat)) {
+    const tokens = parseDataPath(path15);
     if (!tokens || tokens.length === 0) {
       continue;
     }
@@ -11934,8 +12577,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path13, mode) {
-  const normalized = sanitizeElementPath(path13);
+function minimizePathMatchClauses(path15, mode) {
+  const normalized = sanitizeElementPath(path15);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -12039,8 +12682,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path13, mode) {
-  const normalized = sanitizeElementPath(path13);
+function relaxPathForSingleSample(path15, mode) {
+  const normalized = sanitizeElementPath(path15);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -12125,8 +12768,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path13) {
-  const normalized = sanitizeElementPath(path13);
+function buildPathStructureKey(path15) {
+  const normalized = sanitizeElementPath(path15);
   return canonicalJsonString({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -12253,30 +12896,30 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path13, node) {
-  const tokens = parseDataPath(path13);
+function insertNodeAtPath(root, path15, node) {
+  const tokens = parseDataPath(path15);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path13}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path15}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path13}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path15}": 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 "${path13}": expected object segment.`);
+      throw new Error(`Invalid persisted extraction path "${path15}": 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 "${path13}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path15}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -12291,7 +12934,7 @@ function insertNodeAtPath(root, path13, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path13}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path15}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -12326,7 +12969,7 @@ function buildItemRootForArrayIndex(entries) {
   }
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path13) => path13 !== null);
+  ).filter((path15) => path15 !== null);
   if (!paths.length) {
     return null;
   }
@@ -12347,7 +12990,7 @@ function getCommonPathPrefixLength(paths) {
   if (!paths.length) {
     return 0;
   }
-  const nodeChains = paths.map((path13) => path13.nodes);
+  const nodeChains = paths.map((path15) => path15.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) {
     return 0;
@@ -12416,30 +13059,30 @@ function mergeElementPathsByMajority(paths) {
   if (!paths.length) {
     return null;
   }
-  const normalized = paths.map((path13) => sanitizeElementPath(path13));
+  const normalized = paths.map((path15) => sanitizeElementPath(path15));
   const contextKey = pickModeString(
-    normalized.map((path13) => canonicalJsonString(path13.context)),
+    normalized.map((path15) => canonicalJsonString(path15.context)),
     1
   );
   if (!contextKey) {
     return null;
   }
-  const sameContext = normalized.filter((path13) => canonicalJsonString(path13.context) === contextKey);
+  const sameContext = normalized.filter((path15) => canonicalJsonString(path15.context) === contextKey);
   if (!sameContext.length) {
     return null;
   }
   const targetLength = pickModeNumber(
-    sameContext.map((path13) => path13.nodes.length),
+    sameContext.map((path15) => path15.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
-  const aligned = sameContext.filter((path13) => path13.nodes.length === targetLength);
+  const aligned = sameContext.filter((path15) => path15.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((path13) => path13.nodes[index]).filter((node) => node !== void 0);
+    const nodesAtIndex = aligned.map((path15) => path15.nodes[index]).filter((node) => node !== void 0);
     if (!nodesAtIndex.length) {
       return null;
     }
@@ -12685,8 +13328,8 @@ function clonePathContext(context) {
 function clonePathNodes(nodes) {
   return JSON.parse(JSON.stringify(nodes || []));
 }
-function cloneElementPath2(path13) {
-  return JSON.parse(JSON.stringify(path13));
+function cloneElementPath2(path15) {
+  return JSON.parse(JSON.stringify(path15));
 }
 function clonePersistedOpensteerExtractionNode(node) {
   return JSON.parse(JSON.stringify(node));
@@ -13004,8 +13647,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path13) => {
-          node.$path = sanitizeElementPath(path13);
+        replacePath: (path15) => {
+          node.$path = sanitizeElementPath(path15);
         }
       }
     ];
@@ -13019,13 +13662,13 @@ function collectPersistedValueNodeRefs(node) {
   }
   return refs;
 }
-function hasPositionClause(path13) {
-  return path13.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
+function hasPositionClause(path15) {
+  return path15.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
 }
-function stripPositionClauses2(path13) {
+function stripPositionClauses2(path15) {
   return sanitizeElementPath({
-    context: path13.context,
-    nodes: path13.nodes.map((node) => ({
+    context: path15.context,
+    nodes: path15.nodes.map((node) => ({
       ...node,
       match: node.match.filter((clause) => clause.kind !== "position")
     }))
@@ -13435,14 +14078,13 @@ function normalizeNonEmptyString2(name, value) {
 function normalizeKey(value) {
   return String(value ?? "").trim();
 }
-function labelForPath(path13) {
-  return path13.trim().length === 0 ? "$" : path13;
+function labelForPath(path15) {
+  return path15.trim().length === 0 ? "$" : path15;
 }
 function sha256Hex3(value) {
   return createHash("sha256").update(value).digest("hex");
 }
-var PROCESS_LIST_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
-var PS_COMMAND_ENV = { ...process.env, LC_ALL: "C" };
+({ ...process.env});
 var WINDOWS_PROGRAM_FILES = process.env.PROGRAMFILES ?? "C:\\Program Files";
 var WINDOWS_PROGRAM_FILES_X86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
 var BROWSER_BRANDS = [
@@ -13628,9 +14270,6 @@ var BROWSER_BRANDS = [
     }
   }
 ];
-function getAllBrowserBrands() {
-  return BROWSER_BRANDS;
-}
 function getBrowserBrand(id) {
   const brand2 = BROWSER_BRANDS.find((candidate) => candidate.id === id);
   if (!brand2) {
@@ -13673,28 +14312,6 @@ function detectInstalledBrowserBrands() {
   }
   return installations;
 }
-function resolveBrandExecutablePath(brand2, explicitPath) {
-  if (explicitPath !== void 0) {
-    const resolvedPath2 = resolve(expandHome(explicitPath));
-    if (!existsSync(resolvedPath2)) {
-      throw new Error(`${brand2.displayName} executable was not found at "${resolvedPath2}".`);
-    }
-    return resolvedPath2;
-  }
-  const platformConfig = resolveBrandPlatformConfig(brand2);
-  if (!platformConfig) {
-    throw new Error(`${brand2.displayName} is not supported on ${process.platform}.`);
-  }
-  const resolvedPath = firstExistingPath(
-    resolveExecutableCandidates(platformConfig.executableCandidates)
-  );
-  if (!resolvedPath) {
-    throw new Error(
-      `Could not find a ${brand2.displayName} executable. Pass --executable-path or browser.executablePath.`
-    );
-  }
-  return resolvedPath;
-}
 function resolveBrandUserDataDir(brand2, explicitDir) {
   if (explicitDir !== void 0) {
     return resolve(expandHome(explicitDir));
@@ -13705,129 +14322,9 @@ function resolveBrandUserDataDir(brand2, explicitDir) {
   }
   return resolve(expandHome(platformConfig.userDataDir));
 }
-function isBrandProcess(brand2, commandLine) {
-  const normalizedCommand = normalizeCommand(commandLine);
-  if (!normalizedCommand) {
-    return false;
-  }
-  if (normalizedCommand.includes("crashpad_handler")) {
-    return false;
-  }
-  if (/\s--type=/.test(normalizedCommand)) {
-    return false;
-  }
-  return getBrandProcessMarkers(brand2).some((marker) => normalizedCommand.includes(marker));
-}
-function findBrandProcess(brand2) {
-  for (const processEntry of listProcesses()) {
-    if (isBrandProcess(brand2, processEntry.commandLine)) {
-      return { pid: processEntry.pid };
-    }
-  }
-  return null;
-}
-function getBrandProcessMarkers(brand2) {
-  const markers = /* @__PURE__ */ new Set();
-  for (const config of [brand2.darwin, brand2.win32, brand2.linux]) {
-    if (!config) {
-      continue;
-    }
-    for (const processName of config.processNames) {
-      const normalized = normalizeCommand(processName);
-      if (normalized) {
-        markers.add(normalized);
-      }
-    }
-    for (const candidate of config.executableCandidates) {
-      if (!candidate) {
-        continue;
-      }
-      const normalized = normalizeCommand(resolve(expandHome(candidate)));
-      if (normalized) {
-        markers.add(normalized);
-      }
-    }
-  }
-  return [...markers];
-}
 function resolveExecutableCandidates(candidates) {
   return candidates.map((candidate) => candidate ? resolve(expandHome(candidate)) : null);
 }
-function listProcesses() {
-  if (process.platform === "win32") {
-    return listWindowsProcesses();
-  }
-  return listUnixProcesses();
-}
-function listUnixProcesses() {
-  try {
-    const output = execFileSync("ps", ["-A", "-o", "pid=,command="], {
-      encoding: "utf8",
-      env: PS_COMMAND_ENV,
-      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return output.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
-      const match = /^(\d+)\s+(.*)$/.exec(line);
-      if (!match) {
-        return null;
-      }
-      const pid = Number.parseInt(match[1] ?? "", 10);
-      const commandLine = match[2]?.trim() ?? "";
-      if (!Number.isInteger(pid) || pid <= 0 || commandLine.length === 0) {
-        return null;
-      }
-      return {
-        pid,
-        commandLine
-      };
-    }).filter(
-      (entry) => entry !== null
-    ).sort((left, right) => left.pid - right.pid);
-  } catch {
-    return [];
-  }
-}
-function listWindowsProcesses() {
-  try {
-    const output = execFileSync(
-      "powershell.exe",
-      [
-        "-NoProfile",
-        "-Command",
-        "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
-      ],
-      {
-        encoding: "utf8",
-        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES,
-        stdio: ["ignore", "pipe", "ignore"]
-      }
-    ).trim();
-    if (!output) {
-      return [];
-    }
-    const parsed = JSON.parse(output);
-    const records = Array.isArray(parsed) ? parsed : [parsed];
-    return records.map((record) => {
-      const pid = Number(record.ProcessId);
-      const commandLine = typeof record.CommandLine === "string" ? record.CommandLine.trim() : "";
-      if (!Number.isInteger(pid) || pid <= 0 || commandLine.length === 0) {
-        return null;
-      }
-      return {
-        pid,
-        commandLine
-      };
-    }).filter(
-      (entry) => entry !== null
-    ).sort((left, right) => left.pid - right.pid);
-  } catch {
-    return [];
-  }
-}
-function normalizeCommand(value) {
-  return value.trim().replaceAll("\\", "/").toLowerCase();
-}
 
 // src/local-browser/chrome-discovery.ts
 function expandHome(value) {
@@ -14194,8 +14691,8 @@ function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
   const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
   return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
 }
-function normalizeWebSocketPath(path13) {
-  return path13.startsWith("/") ? path13 : `/${path13}`;
+function normalizeWebSocketPath(path15) {
+  return path15.startsWith("/") ? path15 : `/${path15}`;
 }
 function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
   try {
@@ -14215,7 +14712,7 @@ function readPort(url) {
 var OPENSTEER_LIVE_SESSION_LAYOUT = "opensteer-session";
 var OPENSTEER_LIVE_SESSION_VERSION = 1;
 function resolveLiveSessionRecordPath(rootPath, provider) {
-  return path6.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
+  return path7.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
 }
 function resolveLocalSessionRecordPath(rootPath) {
   return resolveLiveSessionRecordPath(rootPath, "local");
@@ -15020,8 +15517,8 @@ var OpensteerBrowserManager = class {
       ...options.browser === void 0 ? {} : { browser: options.browser },
       ...this.contextOptions === void 0 ? {} : { context: this.contextOptions }
     });
-    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path6.join(tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${randomUUID()}`) : resolveFilesystemWorkspacePath({
-      rootDir: path6.resolve(options.rootDir ?? process.cwd()),
+    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7.join(tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${randomUUID()}`) : resolveFilesystemWorkspacePath({
+      rootDir: path7.resolve(options.rootDir ?? process.cwd()),
       workspace: this.workspace
     }));
     this.cleanupRootOnDisconnect = this.workspace === void 0;
@@ -15091,7 +15588,7 @@ var OpensteerBrowserManager = class {
         userDataDir: "browser/user-data",
         bootstrap: {
           kind: "cloneLocalProfile",
-          sourceUserDataDir: path6.resolve(input.sourceUserDataDir),
+          sourceUserDataDir: path7.resolve(input.sourceUserDataDir),
           ...input.sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory: input.sourceProfileDirectory }
         }
       };
@@ -15218,7 +15715,7 @@ var OpensteerBrowserManager = class {
     });
   }
   async createTemporaryEngine() {
-    const userDataDir = await mkdtemp(path6.join(tmpdir(), "opensteer-temporary-browser-"));
+    const userDataDir = await mkdtemp(path7.join(tmpdir(), "opensteer-temporary-browser-"));
     await clearChromeSingletonEntries(userDataDir);
     const launched = await launchOwnedBrowser({
       userDataDir,
@@ -15665,7 +16162,7 @@ async function terminateProcess(pid) {
   }
 }
 async function requestBrowserClose(endpoint) {
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve4, reject) => {
     const socket = new WebSocket(endpoint);
     const timeout = setTimeout(() => {
       socket.close();
@@ -15682,7 +16179,7 @@ async function requestBrowserClose(endpoint) {
         reject(error);
         return;
       }
-      resolve5();
+      resolve4();
     };
     socket.addEventListener("open", () => {
       socket.send(JSON.stringify({ id: 1, method: "Browser.close" }));
@@ -15720,7 +16217,7 @@ async function waitForProcessExit(pid, timeoutMs) {
   return !isProcessRunning(pid);
 }
 function resolveAbpSessionDir(workspace) {
-  return path6.join(workspace.livePath, "abp-session");
+  return path7.join(workspace.livePath, "abp-session");
 }
 async function allocateEphemeralPort() {
   const { allocatePort } = await loadAbpModule();
@@ -15778,7 +16275,7 @@ function isStealthProfile(input) {
   return input.id !== void 0 && input.platform !== void 0 && input.browserBrand !== void 0 && input.browserVersion !== void 0 && input.userAgent !== void 0 && input.viewport !== void 0 && input.screenResolution !== void 0 && input.devicePixelRatio !== void 0 && input.maxTouchPoints !== void 0 && input.webglVendor !== void 0 && input.webglRenderer !== void 0 && input.fonts !== void 0 && input.canvasNoiseSeed !== void 0 && input.audioNoiseSeed !== void 0 && input.locale !== void 0 && input.timezoneId !== void 0;
 }
 async function sleep(ms) {
-  await new Promise((resolve5) => setTimeout(resolve5, ms));
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 // ../runtime-core/src/sdk/semantic-dispatch.ts
@@ -16044,7 +16541,7 @@ async function dispatchSemanticOperation(runtime, operation, input, options = {}
 
 // ../runtime-core/package.json
 var package_default = {
-  version: "0.1.1"};
+  version: "0.1.2"};
 
 // ../runtime-core/src/version.ts
 var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
@@ -16345,6 +16842,7 @@ var DefaultComputerUseRuntime = class {
     const snapshot = await input.timeout.runStep(
       () => captureActionBoundarySnapshot(this.options.engine, input.pageRef)
     );
+    let visualSettled = true;
     const executed = await input.timeout.runStep(
       () => bridge.execute({
         pageRef: input.pageRef,
@@ -16353,16 +16851,35 @@ var DefaultComputerUseRuntime = class {
         screenshot,
         signal: input.timeout.signal,
         remainingMs: () => input.timeout.remainingMs(),
-        policySettle: async (pageRef, trigger) => settleWithPolicy(this.options.policy.settle, {
-          operation: "computer.execute",
-          trigger,
-          engine: this.options.engine,
-          pageRef,
-          signal: input.timeout.signal,
-          remainingMs: input.timeout.remainingMs()
-        })
+        policySettle: async (pageRef, trigger) => {
+          try {
+            await settleWithPolicy(this.options.policy.settle, {
+              operation: "computer.execute",
+              trigger,
+              engine: this.options.engine,
+              pageRef,
+              signal: input.timeout.signal,
+              remainingMs: input.timeout.remainingMs()
+            });
+          } catch (error) {
+            if (pageRef === input.pageRef && isSoftSettleTimeoutError(error, input.timeout.signal)) {
+              visualSettled = false;
+              return;
+            }
+            throw error;
+          }
+        }
       })
     );
+    if (executed.boundary !== void 0 && executed.pageRef === input.pageRef) {
+      recordActionBoundaryDiagnostics(
+        input.timeout.signal,
+        createActionBoundaryDiagnostics({
+          boundary: executed.boundary,
+          visualSettled
+        })
+      );
+    }
     let trace = void 0;
     if (!input.timeout.signal.aborted) {
       try {
@@ -17372,7 +17889,7 @@ function diffStringMap(prefix, left, right, includeUnchanged, output) {
     diffScalarField(`${prefix}.${key}`, left[key], right[key], includeUnchanged, output);
   }
 }
-function diffScalarField(path13, left, right, includeUnchanged, output) {
+function diffScalarField(path15, 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";
@@ -17380,7 +17897,7 @@ function diffScalarField(path13, left, right, includeUnchanged, output) {
     return;
   }
   output.push({
-    path: path13,
+    path: path15,
     kind,
     ...leftValue === void 0 ? {} : { leftValue },
     ...rightValue === void 0 ? {} : { rightValue },
@@ -17474,7 +17991,7 @@ function resolveBodyEncoding(charset) {
 var NetworkHistory = class {
   metadataByRequestId = /* @__PURE__ */ new Map();
   requestIdByRecordId = /* @__PURE__ */ new Map();
-  requestIdsByActionId = /* @__PURE__ */ new Map();
+  requestIdsByCapture = /* @__PURE__ */ new Map();
   requestIdsByTag = /* @__PURE__ */ new Map();
   tombstonedRequestIds = /* @__PURE__ */ new Set();
   materialize(records, options = {}) {
@@ -17521,17 +18038,17 @@ var NetworkHistory = class {
     }
     return persisted;
   }
-  assignActionId(records, actionId) {
+  assignCapture(records, capture) {
     for (const record of records) {
       const metadata = this.metadataByRequestId.get(record.record.requestId);
-      if (!metadata || metadata.actionId === actionId) {
+      if (!metadata || metadata.capture === capture) {
         continue;
       }
-      if (metadata.actionId !== void 0) {
-        this.requestIdsByActionId.get(metadata.actionId)?.delete(record.record.requestId);
+      if (metadata.capture !== void 0) {
+        this.requestIdsByCapture.get(metadata.capture)?.delete(record.record.requestId);
       }
-      metadata.actionId = actionId;
-      this.addIndexedRequestId(this.requestIdsByActionId, actionId, record.record.requestId);
+      metadata.capture = capture;
+      this.addIndexedRequestId(this.requestIdsByCapture, capture, record.record.requestId);
     }
   }
   addTag(records, tag) {
@@ -17551,8 +18068,8 @@ var NetworkHistory = class {
   getRequestId(recordId) {
     return this.requestIdByRecordId.get(recordId);
   }
-  getRequestIdsForActionId(actionId) {
-    return new Set(this.requestIdsByActionId.get(actionId) ?? []);
+  getRequestIdsForCapture(capture) {
+    return new Set(this.requestIdsByCapture.get(capture) ?? []);
   }
   getRequestIdsForTag(tag) {
     return new Set(this.requestIdsByTag.get(tag) ?? []);
@@ -17563,20 +18080,6 @@ var NetworkHistory = class {
   getKnownRequestIds() {
     return new Set(this.metadataByRequestId.keys());
   }
-  clearTag(tag) {
-    const requestIds = [...this.requestIdsByTag.get(tag) ?? []];
-    this.requestIdsByTag.delete(tag);
-    for (const requestId of requestIds) {
-      const metadata = this.metadataByRequestId.get(requestId);
-      if (!metadata) {
-        continue;
-      }
-      metadata.tags.delete(tag);
-      if (metadata.tags.size === 0) {
-        this.tombstoneRequestIds([requestId]);
-      }
-    }
-  }
   tombstoneRequestIds(requestIds) {
     for (const requestId of requestIds) {
       this.tombstonedRequestIds.add(requestId);
@@ -17586,8 +18089,8 @@ var NetworkHistory = class {
       }
       this.metadataByRequestId.delete(requestId);
       this.requestIdByRecordId.delete(metadata.recordId);
-      if (metadata.actionId !== void 0) {
-        this.requestIdsByActionId.get(metadata.actionId)?.delete(requestId);
+      if (metadata.capture !== void 0) {
+        this.requestIdsByCapture.get(metadata.capture)?.delete(requestId);
       }
       for (const tag of metadata.tags) {
         this.requestIdsByTag.get(tag)?.delete(requestId);
@@ -17597,7 +18100,7 @@ var NetworkHistory = class {
   clear() {
     this.metadataByRequestId.clear();
     this.requestIdByRecordId.clear();
-    this.requestIdsByActionId.clear();
+    this.requestIdsByCapture.clear();
     this.requestIdsByTag.clear();
     this.tombstonedRequestIds.clear();
   }
@@ -17620,7 +18123,7 @@ var NetworkHistory = class {
     }
     return {
       recordId: metadata.recordId,
-      ...metadata.actionId === void 0 ? {} : { actionId: metadata.actionId },
+      ...metadata.capture === void 0 ? {} : { capture: metadata.capture },
       ...metadata.tags.size === 0 ? {} : { tags: [...metadata.tags].sort() },
       ...metadata.savedAt === void 0 ? {} : { savedAt: metadata.savedAt },
       record: toProtocolNetworkRecord(record, {
@@ -18400,9 +18903,9 @@ function matchReverseTargetHints(channel, codec, targetHints) {
       matches.add(`host:${host}`);
     }
   }
-  for (const path13 of targetHints.paths ?? []) {
-    if (url.pathname.includes(path13)) {
-      matches.add(`path:${path13}`);
+  for (const path15 of targetHints.paths ?? []) {
+    if (url.pathname.includes(path15)) {
+      matches.add(`path:${path15}`);
     }
   }
   for (const operationName of targetHints.operationNames ?? []) {
@@ -19363,11 +19866,11 @@ function inferClusterRelationship(seed, record) {
 var MATCHED_TLS_BINARY_NAMES = ["curl-impersonate-chrome", "curl_chrome"];
 async function executeMatchedTlsTransportRequest(input) {
   const binary = await resolveMatchedTlsBinary();
-  const workingDirectory = await mkdtemp(path6.join(tmpdir(), "opensteer-matched-tls-"));
-  const headersPath = path6.join(workingDirectory, "headers.txt");
-  const bodyPath = path6.join(workingDirectory, "body.bin");
-  const cookiesPath = path6.join(workingDirectory, "cookies.txt");
-  const requestBodyPath = path6.join(workingDirectory, "request-body.bin");
+  const workingDirectory = await mkdtemp(path7.join(tmpdir(), "opensteer-matched-tls-"));
+  const headersPath = path7.join(workingDirectory, "headers.txt");
+  const bodyPath = path7.join(workingDirectory, "body.bin");
+  const cookiesPath = path7.join(workingDirectory, "cookies.txt");
+  const requestBodyPath = path7.join(workingDirectory, "request-body.bin");
   try {
     await writeFile(cookiesPath, toNetscapeCookieJar(input.cookies ?? []), "utf8");
     if (input.request.body !== void 0) {
@@ -19424,10 +19927,10 @@ async function executeMatchedTlsTransportRequest(input) {
   }
 }
 async function resolveMatchedTlsBinary() {
-  const pathEntries = (process.env.PATH ?? "").split(path6.delimiter).filter((entry) => entry.length > 0);
+  const pathEntries = (process.env.PATH ?? "").split(path7.delimiter).filter((entry) => entry.length > 0);
   for (const directory of pathEntries) {
     for (const name of MATCHED_TLS_BINARY_NAMES) {
-      const candidate = path6.join(directory, name);
+      const candidate = path7.join(directory, name);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -19435,7 +19938,7 @@ async function resolveMatchedTlsBinary() {
     const files = await readDirSafe(directory);
     const discovered = files.find((file) => file.startsWith("curl_chrome"));
     if (discovered !== void 0) {
-      const candidate = path6.join(directory, discovered);
+      const candidate = path7.join(directory, discovered);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -19446,7 +19949,7 @@ async function resolveMatchedTlsBinary() {
   );
 }
 async function spawnAndCollect(command, args, signal) {
-  return await new Promise((resolve5, reject) => {
+  return await new Promise((resolve4, reject) => {
     const child = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -19479,7 +19982,7 @@ async function spawnAndCollect(command, args, signal) {
         );
         return;
       }
-      resolve5({ stdout, stderr });
+      resolve4({ stdout, stderr });
     });
   });
 }
@@ -22141,8 +22644,8 @@ function readString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function sleep2(ms, signal) {
-  return new Promise((resolve5, reject) => {
-    const timeout = setTimeout(resolve5, ms);
+  return new Promise((resolve4, reject) => {
+    const timeout = setTimeout(resolve4, ms);
     const abort = () => {
       clearTimeout(timeout);
       reject(new Error("captcha solve aborted"));
@@ -22239,8 +22742,8 @@ function readString2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function sleep3(ms, signal) {
-  return new Promise((resolve5, reject) => {
-    const timeout = setTimeout(resolve5, ms);
+  return new Promise((resolve4, reject) => {
+    const timeout = setTimeout(resolve4, ms);
     const abort = () => {
       clearTimeout(timeout);
       reject(new Error("captcha solve aborted"));
@@ -22438,6 +22941,9 @@ function diffInteractionTraces(left, right) {
 
 // ../runtime-core/src/sdk/runtime.ts
 var requireForAuthRecipeHook = createRequire(import.meta.url);
+var MUTATION_CAPTURE_FINALIZE_TIMEOUT_MS = 5e3;
+var PENDING_OPERATION_EVENT_CAPTURE_LIMIT = 64;
+var PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS = 1e3;
 var OpensteerSessionRuntime = class {
   workspace;
   rootPath;
@@ -22450,6 +22956,9 @@ var OpensteerSessionRuntime = class {
   registryOverrides;
   cleanupRootOnClose;
   sessionInfoBase;
+  observationConfig;
+  observationSessionId;
+  injectedObservationSink;
   root;
   engine;
   dom;
@@ -22459,6 +22968,9 @@ var OpensteerSessionRuntime = class {
   sessionRef;
   pageRef;
   runId;
+  observations;
+  operationEventStorage = new AsyncLocalStorage();
+  pendingOperationEventCaptures = [];
   cookieJars = /* @__PURE__ */ new Map();
   recipeCache = /* @__PURE__ */ new Map();
   ownsEngine = false;
@@ -22466,7 +22978,7 @@ var OpensteerSessionRuntime = class {
     this.workspace = normalizeNamespace2(options.name);
     this.workspaceName = options.workspaceName?.trim() === void 0 || options.workspaceName?.trim().length === 0 ? void 0 : options.workspaceName.trim();
     this.root = options.workspace;
-    this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path6.resolve(process.cwd(), ".opensteer", "temporary", randomUUID());
+    this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path7.resolve(process.cwd(), ".opensteer", "temporary", randomUUID());
     this.injectedEngine = options.engine;
     this.engineFactory = options.engineFactory;
     this.policy = options.policy ?? defaultPolicy();
@@ -22475,6 +22987,9 @@ var OpensteerSessionRuntime = class {
     this.registryOverrides = options.registryOverrides;
     this.cleanupRootOnClose = options.cleanupRootOnClose ?? options.workspace === void 0;
     this.sessionInfoBase = options.sessionInfo ?? {};
+    this.observationConfig = normalizeObservabilityConfig(options.observability);
+    this.observationSessionId = options.observationSessionId;
+    this.injectedObservationSink = options.observationSink;
     if (this.injectedEngine === void 0 && this.engineFactory === void 0) {
       throw new Error("OpensteerSessionRuntime requires an engine or engineFactory.");
     }
@@ -22506,6 +23021,20 @@ var OpensteerSessionRuntime = class {
       }
     };
   }
+  async setObservabilityConfig(input) {
+    this.observationConfig = normalizeObservabilityConfig(input);
+    const observationSessionId = this.resolveObservationSessionId();
+    if (observationSessionId === void 0) {
+      return this.observationConfig;
+    }
+    const sink = this.injectedObservationSink ?? (await this.ensureRoot()).observations;
+    this.observations = await sink.openSession({
+      sessionId: observationSessionId,
+      openedAt: Date.now(),
+      config: this.observationConfig
+    });
+    return this.observationConfig;
+  }
   async open(input = {}, options = {}) {
     assertValidSemanticOperationInput("session.open", input);
     if (input.workspace !== void 0 && normalizeNamespace2(input.workspace) !== this.workspace) {
@@ -22604,6 +23133,10 @@ var OpensteerSessionRuntime = class {
       return { pages: [] };
     }
     const startedAt = Date.now();
+    const context = buildRuntimeTraceContext({
+      sessionRef: this.sessionRef,
+      pageRef: this.pageRef
+    });
     try {
       const output = await this.runWithOperationTimeout(
         "page.list",
@@ -22618,19 +23151,18 @@ var OpensteerSessionRuntime = class {
         },
         options
       );
+      const events = await this.drainPendingEngineEvents(context);
       await this.appendTrace({
         operation: "page.list",
         startedAt,
         completedAt: Date.now(),
         outcome: "ok",
+        ...events === void 0 ? {} : { events },
         data: {
           count: output.pages.length,
           ...output.activePageRef === void 0 ? {} : { activePageRef: output.activePageRef }
         },
-        context: buildRuntimeTraceContext({
-          sessionRef: this.sessionRef,
-          pageRef: this.pageRef
-        })
+        context
       });
       return output;
     } catch (error) {
@@ -22640,10 +23172,7 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "error",
         error,
-        context: buildRuntimeTraceContext({
-          sessionRef: this.sessionRef,
-          pageRef: this.pageRef
-        })
+        context
       });
       throw error;
     }
@@ -22820,34 +23349,32 @@ var OpensteerSessionRuntime = class {
     assertValidSemanticOperationInput("page.goto", input);
     const pageRef = await this.ensurePageRef();
     const startedAt = Date.now();
+    let mutationCaptureDiagnostics;
     try {
-      const { navigation, state } = await this.runWithOperationTimeout(
+      const { navigation, state } = await this.runMutationCapturedOperation(
         "page.goto",
+        {
+          ...input.captureNetwork === void 0 ? {} : { captureNetwork: input.captureNetwork },
+          options
+        },
         async (timeout) => {
-          const baselineRequestIds = await this.beginMutationCapture(timeout);
-          try {
-            const navigation2 = await this.navigatePage(
-              {
-                operation: "page.goto",
-                pageRef,
-                url: input.url
-              },
-              timeout
-            );
-            timeout.throwIfAborted();
-            await this.completeMutationCapture(timeout, baselineRequestIds, input.networkTag);
-            return {
-              navigation: navigation2,
-              state: await timeout.runStep(() => this.readSessionState())
-            };
-          } catch (error) {
-            await this.completeMutationCapture(timeout, baselineRequestIds, input.networkTag).catch(
-              () => void 0
-            );
-            throw error;
-          }
+          const navigation2 = await this.navigatePage(
+            {
+              operation: "page.goto",
+              pageRef,
+              url: input.url
+            },
+            timeout
+          );
+          timeout.throwIfAborted();
+          return {
+            navigation: navigation2,
+            state: await timeout.runStep(() => this.readSessionState())
+          };
         },
-        options
+        (diagnostics) => {
+          mutationCaptureDiagnostics = diagnostics;
+        }
       );
       await this.appendTrace({
         operation: "page.goto",
@@ -22856,7 +23383,8 @@ var OpensteerSessionRuntime = class {
         outcome: "ok",
         data: {
           url: input.url,
-          state
+          state,
+          ...buildMutationCaptureTraceData(mutationCaptureDiagnostics)
         },
         context: buildRuntimeTraceContext({
           sessionRef: this.sessionRef,
@@ -22872,6 +23400,7 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "error",
         error,
+        data: buildMutationCaptureTraceData(mutationCaptureDiagnostics),
         context: buildRuntimeTraceContext({
           sessionRef: this.sessionRef,
           pageRef
@@ -22884,34 +23413,29 @@ var OpensteerSessionRuntime = class {
     assertValidSemanticOperationInput("page.evaluate", input);
     const pageRef = input.pageRef ?? await this.ensurePageRef();
     const startedAt = Date.now();
+    let mutationCaptureDiagnostics;
     try {
-      const output = await this.runWithOperationTimeout(
+      const output = await this.runMutationCapturedOperation(
         "page.evaluate",
+        { options },
         async (timeout) => {
-          const baselineRequestIds = await this.beginMutationCapture(timeout);
-          try {
-            const remainingMs = timeout.remainingMs();
-            const evaluated = await timeout.runStep(
-              () => this.requireEngine().evaluatePage({
-                pageRef,
-                script: input.script,
-                ...input.args === void 0 ? {} : { args: input.args },
-                ...remainingMs === void 0 ? {} : { timeoutMs: remainingMs }
-              })
-            );
-            await this.completeMutationCapture(timeout, baselineRequestIds, void 0);
-            return {
+          const remainingMs = timeout.remainingMs();
+          const evaluated = await timeout.runStep(
+            () => this.requireEngine().evaluatePage({
               pageRef,
-              value: toJsonValueOrNull(evaluated.data)
-            };
-          } catch (error) {
-            await this.completeMutationCapture(timeout, baselineRequestIds, void 0).catch(
-              () => void 0
-            );
-            throw error;
-          }
+              script: input.script,
+              ...input.args === void 0 ? {} : { args: input.args },
+              ...remainingMs === void 0 ? {} : { timeoutMs: remainingMs }
+            })
+          );
+          return {
+            pageRef,
+            value: toJsonValueOrNull(evaluated.data)
+          };
         },
-        options
+        (diagnostics) => {
+          mutationCaptureDiagnostics = diagnostics;
+        }
       );
       await this.appendTrace({
         operation: "page.evaluate",
@@ -22920,7 +23444,8 @@ var OpensteerSessionRuntime = class {
         outcome: "ok",
         data: {
           pageRef: output.pageRef,
-          value: output.value
+          value: output.value,
+          ...buildMutationCaptureTraceData(mutationCaptureDiagnostics)
         },
         context: buildRuntimeTraceContext({
           sessionRef: this.sessionRef,
@@ -22935,6 +23460,7 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "error",
         error,
+        data: buildMutationCaptureTraceData(mutationCaptureDiagnostics),
         context: buildRuntimeTraceContext({
           sessionRef: this.sessionRef,
           pageRef
@@ -23034,22 +23560,25 @@ var OpensteerSessionRuntime = class {
         },
         options
       );
+      const context = buildRuntimeTraceContext({
+        sessionRef: this.sessionRef,
+        pageRef
+      });
+      const events = await this.drainPendingEngineEvents(context);
       await this.appendTrace({
         operation: "page.snapshot",
         startedAt,
         completedAt: Date.now(),
         outcome: "ok",
         artifacts,
+        ...events === void 0 ? {} : { events },
         data: {
           mode,
           url: output.url,
           title: output.title,
           counterCount: output.counters.length
         },
-        context: buildRuntimeTraceContext({
-          sessionRef: this.sessionRef,
-          pageRef
-        })
+        context
       });
       return output;
     } catch (error) {
@@ -23374,17 +23903,29 @@ var OpensteerSessionRuntime = class {
         "network.clear",
         async (timeout) => {
           if (this.sessionRef !== void 0) {
-            const liveRequestIds = await this.readLiveRequestIds(timeout, {
-              includeCurrentPageOnly: false
-            });
-            if (input.tag === void 0) {
+            if (input.capture !== void 0 || input.tag !== void 0) {
+              const records = await this.queryLiveNetwork(
+                {
+                  ...input.capture === void 0 ? {} : { capture: input.capture },
+                  ...input.tag === void 0 ? {} : { tag: input.tag }
+                },
+                timeout,
+                {
+                  ignoreLimit: true
+                }
+              );
+              this.networkHistory.tombstoneRequestIds(
+                records.map((record) => record.record.requestId)
+              );
+            } else {
+              const liveRequestIds = await this.readLiveRequestIds(timeout, {
+                includeCurrentPageOnly: false
+              });
               this.networkHistory.tombstoneRequestIds(liveRequestIds);
             }
           }
-          if (input.tag === void 0) {
+          if (input.capture === void 0 && input.tag === void 0) {
             this.networkHistory.tombstoneRequestIds(this.networkHistory.getKnownRequestIds());
-          } else {
-            this.networkHistory.clearTag(input.tag);
           }
           return {
             clearedCount: await timeout.runStep(() => root.registry.savedNetwork.clear(input))
@@ -23398,6 +23939,7 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "ok",
         data: {
+          ...input.capture === void 0 ? {} : { capture: input.capture },
           ...input.tag === void 0 ? {} : { tag: input.tag },
           clearedCount: output.clearedCount
         }
@@ -24579,7 +25121,9 @@ var OpensteerSessionRuntime = class {
       };
     }
     const bindings = /* @__PURE__ */ new Map();
-    const baselineRequestIds = await this.beginMutationCapture(timeout);
+    const baselineRequestIds = await this.readLiveRequestIds(timeout, {
+      includeCurrentPageOnly: true
+    });
     const pageRef = explicitPageRef ?? await this.ensurePageRef();
     const validatorMap = new Map(
       packageRecord.payload.validators.map((validator) => [validator.id, validator])
@@ -26251,33 +26795,38 @@ var OpensteerSessionRuntime = class {
     assertValidSemanticOperationInput("computer.execute", input);
     const pageRef = await this.ensurePageRef();
     const startedAt = Date.now();
+    let mutationCaptureDiagnostics;
+    let boundaryDiagnostics;
     try {
-      const { artifacts, output } = await this.runWithOperationTimeout(
+      const { artifacts, output } = await this.runMutationCapturedOperation(
         "computer.execute",
+        {
+          ...input.captureNetwork === void 0 ? {} : { captureNetwork: input.captureNetwork },
+          options
+        },
         async (timeout) => {
-          const baselineRequestIds = await this.beginMutationCapture(timeout);
           try {
             const output2 = await this.requireComputer().execute({
               pageRef,
               input,
               timeout
             });
+            boundaryDiagnostics = takeActionBoundaryDiagnostics(timeout.signal);
             timeout.throwIfAborted();
             this.pageRef = output2.pageRef;
-            await this.completeMutationCapture(timeout, baselineRequestIds, input.networkTag);
             const artifacts2 = await this.persistComputerArtifacts(output2, timeout);
             return {
               artifacts: { manifests: artifacts2.manifests },
               output: artifacts2.output
             };
           } catch (error) {
-            await this.completeMutationCapture(timeout, baselineRequestIds, input.networkTag).catch(
-              () => void 0
-            );
+            boundaryDiagnostics ??= takeActionBoundaryDiagnostics(timeout.signal);
             throw error;
           }
         },
-        options
+        (diagnostics) => {
+          mutationCaptureDiagnostics = diagnostics;
+        }
       );
       await this.appendTrace({
         operation: "computer.execute",
@@ -26293,6 +26842,8 @@ var OpensteerSessionRuntime = class {
           nativeViewport: output.nativeViewport,
           displayScale: output.displayScale,
           timing: output.timing,
+          ...boundaryDiagnostics === void 0 ? {} : { settle: boundaryDiagnostics },
+          ...buildMutationCaptureTraceData(mutationCaptureDiagnostics),
           ...output.trace === void 0 ? {} : { trace: output.trace }
         },
         context: buildRuntimeTraceContext({
@@ -26311,6 +26862,10 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "error",
         error,
+        data: {
+          ...boundaryDiagnostics === void 0 ? {} : { settle: boundaryDiagnostics },
+          ...buildMutationCaptureTraceData(mutationCaptureDiagnostics)
+        },
         context: buildRuntimeTraceContext({
           sessionRef: this.sessionRef,
           pageRef: this.pageRef
@@ -26414,44 +26969,53 @@ var OpensteerSessionRuntime = class {
   async runDomAction(operation, input, executor, options = {}) {
     const pageRef = await this.ensurePageRef();
     const startedAt = Date.now();
+    let mutationCaptureDiagnostics;
+    let boundaryDiagnostics;
     try {
-      const { executed, preparedTarget } = await this.runWithOperationTimeout(
+      const { executed, preparedTarget } = await this.runMutationCapturedOperation(
         operation,
+        {
+          ...input.captureNetwork === void 0 ? {} : { captureNetwork: input.captureNetwork },
+          options
+        },
         async (timeout) => {
-          const baselineRequestIds = await this.beginMutationCapture(timeout);
+          const preparedTarget2 = await this.prepareDomTarget(
+            pageRef,
+            operation,
+            input.target,
+            input.persistAsDescription,
+            timeout
+          );
           try {
-            const preparedTarget2 = await this.prepareDomTarget(
-              pageRef,
-              operation,
-              input.target,
-              input.persistAsDescription,
-              timeout
-            );
             const executed2 = await executor(pageRef, preparedTarget2.target, timeout);
-            await this.completeMutationCapture(timeout, baselineRequestIds, input.networkTag);
+            boundaryDiagnostics = takeActionBoundaryDiagnostics(timeout.signal);
             return {
               executed: executed2,
               preparedTarget: preparedTarget2
             };
           } catch (error) {
-            await this.completeMutationCapture(timeout, baselineRequestIds, input.networkTag).catch(
-              () => void 0
-            );
+            boundaryDiagnostics ??= takeActionBoundaryDiagnostics(timeout.signal);
             throw error;
           }
         },
-        options
+        (diagnostics) => {
+          mutationCaptureDiagnostics = diagnostics;
+        }
       );
       const output = toOpensteerActionResult(executed.result, preparedTarget.persistedDescription);
+      const actionEvents = "events" in executed.result ? executed.result.events : void 0;
       await this.appendTrace({
         operation,
         startedAt,
         completedAt: Date.now(),
         outcome: "ok",
+        ...actionEvents === void 0 ? {} : { events: actionEvents },
         data: {
           target: output.target,
           ...output.point === void 0 ? {} : { point: output.point },
-          ...output.persistedDescription === void 0 ? {} : { persistedDescription: output.persistedDescription }
+          ...output.persistedDescription === void 0 ? {} : { persistedDescription: output.persistedDescription },
+          ...boundaryDiagnostics === void 0 ? {} : { settle: boundaryDiagnostics },
+          ...buildMutationCaptureTraceData(mutationCaptureDiagnostics)
         },
         context: buildRuntimeTraceContext({
           sessionRef: this.sessionRef,
@@ -26469,6 +27033,10 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "error",
         error,
+        data: {
+          ...boundaryDiagnostics === void 0 ? {} : { settle: boundaryDiagnostics },
+          ...buildMutationCaptureTraceData(mutationCaptureDiagnostics)
+        },
         context: buildRuntimeTraceContext({
           sessionRef: this.sessionRef,
           pageRef
@@ -26578,7 +27146,7 @@ var OpensteerSessionRuntime = class {
     const filtered = filterNetworkQueryRecords(metadataRecords, {
       ...input.recordId === void 0 ? {} : { recordId: input.recordId },
       ...input.requestId === void 0 ? {} : { requestId: input.requestId },
-      ...input.actionId === void 0 ? {} : { actionId: input.actionId },
+      ...input.capture === void 0 ? {} : { capture: input.capture },
       ...input.tag === void 0 ? {} : { tag: input.tag },
       ...input.url === void 0 ? {} : { url: input.url },
       ...input.hostname === void 0 ? {} : { hostname: input.hostname },
@@ -26784,32 +27352,68 @@ var OpensteerSessionRuntime = class {
       artifactId: manifest.artifactId
     };
   }
-  beginMutationCapture(timeout) {
-    return this.readLiveRequestIds(timeout, {
-      includeCurrentPageOnly: true
-    });
-  }
-  async completeMutationCapture(timeout, baselineRequestIds, networkTag) {
-    const records = await timeout.runStep(
-      () => this.readLiveNetworkRecords(
-        {
-          includeBodies: false,
-          includeCurrentPageOnly: true
+  async runMutationCapturedOperation(operation, input, execute, onFinalized) {
+    let plan;
+    try {
+      const result = await this.runWithOperationTimeout(
+        operation,
+        async (timeout) => {
+          plan = await this.beginMutationCapture(timeout, input.captureNetwork);
+          return execute(timeout);
         },
-        timeout.signal
-      )
+        input.options
+      );
+      const diagnostics = await this.finalizeMutationCaptureBestEffort(plan);
+      onFinalized?.(diagnostics);
+      return result;
+    } catch (error) {
+      const diagnostics = await this.finalizeMutationCaptureBestEffort(plan);
+      onFinalized?.(diagnostics);
+      throw error;
+    }
+  }
+  async beginMutationCapture(timeout, capture) {
+    if (capture === void 0) {
+      return void 0;
+    }
+    return {
+      baselineRequestIds: await this.readLiveRequestIds(timeout, {
+        includeCurrentPageOnly: true
+      }),
+      capture
+    };
+  }
+  async finalizeMutationCaptureBestEffort(plan) {
+    if (plan === void 0) {
+      return {};
+    }
+    try {
+      await withDetachedTimeoutSignal(MUTATION_CAPTURE_FINALIZE_TIMEOUT_MS, async (signal) => {
+        await this.completeMutationCaptureWithSignal(signal, plan);
+      });
+      return {};
+    } catch (error) {
+      return {
+        finalizeError: normalizeOpensteerError(error)
+      };
+    }
+  }
+  async completeMutationCaptureWithSignal(signal, plan) {
+    const records = await this.readLiveNetworkRecords(
+      {
+        includeBodies: false,
+        includeCurrentPageOnly: true
+      },
+      signal
     );
-    const delta = records.filter((record) => !baselineRequestIds.has(record.record.requestId));
+    const delta = records.filter((record) => !plan.baselineRequestIds.has(record.record.requestId));
     if (delta.length === 0) {
       return;
     }
-    this.networkHistory.assignActionId(delta, `action:${randomUUID()}`);
-    if (networkTag !== void 0) {
-      this.networkHistory.addTag(delta, networkTag);
-    }
-    await this.persistLiveRequestIds(
+    this.networkHistory.assignCapture(delta, plan.capture);
+    await this.persistLiveRequestIdsWithSignal(
       delta.map((record) => record.record.requestId),
-      timeout,
+      signal,
       {
         includeCurrentPageOnly: true
       }
@@ -27216,27 +27820,28 @@ var OpensteerSessionRuntime = class {
     });
   }
   async persistLiveRequestIds(requestIds, timeout, options) {
+    return timeout.runStep(
+      () => this.persistLiveRequestIdsWithSignal(requestIds, timeout.signal, options)
+    );
+  }
+  async persistLiveRequestIdsWithSignal(requestIds, signal, options) {
     if (requestIds.length === 0) {
       return [];
     }
     const root = await this.ensureRoot();
-    const browserRecords = await timeout.runStep(
-      () => this.readBrowserNetworkRecords(
-        {
-          includeBodies: true,
-          includeCurrentPageOnly: options.includeCurrentPageOnly,
-          ...options.pageRef === void 0 ? {} : { pageRef: options.pageRef },
-          requestIds
-        },
-        timeout.signal
-      )
-    );
-    return timeout.runStep(
-      () => this.networkHistory.persist(browserRecords, root.registry.savedNetwork, {
-        bodyWriteMode: "authoritative",
-        redactSecretHeaders: false
-      })
+    const browserRecords = await this.readBrowserNetworkRecords(
+      {
+        includeBodies: true,
+        includeCurrentPageOnly: options.includeCurrentPageOnly,
+        ...options.pageRef === void 0 ? {} : { pageRef: options.pageRef },
+        requestIds
+      },
+      signal
     );
+    return this.networkHistory.persist(browserRecords, root.registry.savedNetwork, {
+      bodyWriteMode: "authoritative",
+      redactSecretHeaders: false
+    });
   }
   async syncPersistedNetworkSelection(timeout, input, options) {
     if (this.sessionRef === void 0) {
@@ -27278,7 +27883,7 @@ var OpensteerSessionRuntime = class {
       ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef },
       ...input.recordId === void 0 ? {} : { recordId: input.recordId },
       ...input.requestId === void 0 ? {} : { requestId: input.requestId },
-      ...input.actionId === void 0 ? {} : { actionId: input.actionId },
+      ...input.capture === void 0 ? {} : { capture: input.capture },
       ...input.tag === void 0 ? {} : { tag: input.tag },
       ...input.url === void 0 ? {} : { url: input.url },
       ...input.hostname === void 0 ? {} : { hostname: input.hostname },
@@ -27295,7 +27900,7 @@ var OpensteerSessionRuntime = class {
       ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef },
       ...input.recordId === void 0 ? {} : { recordId: input.recordId },
       ...input.requestId === void 0 ? {} : { requestId: input.requestId },
-      ...input.actionId === void 0 ? {} : { actionId: input.actionId },
+      ...input.capture === void 0 ? {} : { capture: input.capture },
       ...input.url === void 0 ? {} : { url: input.url },
       ...input.hostname === void 0 ? {} : { hostname: input.hostname },
       ...input.path === void 0 ? {} : { path: input.path },
@@ -28154,7 +28759,7 @@ var OpensteerSessionRuntime = class {
   }
   async executeAuthRecipeHook(step, variables) {
     const resolved = requireForAuthRecipeHook.resolve(step.hook.specifier, {
-      paths: [path6.dirname(this.rootPath)]
+      paths: [path7.dirname(this.rootPath)]
     });
     const module = await import(pathToFileURL(resolved).href);
     const handler = module[step.hook.export];
@@ -28526,14 +29131,18 @@ var OpensteerSessionRuntime = class {
       return this.engine;
     }
     if (this.injectedEngine) {
-      this.engine = this.injectedEngine;
+      this.engine = this.wrapEngineWithObservationCapture(
+        this.injectedEngine
+      );
       this.ownsEngine = false;
       return this.engine;
     }
     if (this.engineFactory === void 0) {
       throw new Error("Opensteer engine factory is not initialized");
     }
-    this.engine = await this.engineFactory(overrides);
+    this.engine = this.wrapEngineWithObservationCapture(
+      await this.engineFactory(overrides)
+    );
     this.ownsEngine = true;
     return this.engine;
   }
@@ -28733,6 +29342,15 @@ var OpensteerSessionRuntime = class {
       return;
     }
     const root = await this.ensureRoot();
+    const capturedStepEvents = input.events ?? this.consumePendingOperationEventCapture(
+      input.operation,
+      input.startedAt,
+      input.completedAt
+    );
+    const drainedStepEvents = input.events === void 0 ? await this.drainPendingEngineEvents(input.context) : void 0;
+    const stepEvents = mergeObservedStepEvents(capturedStepEvents, drainedStepEvents);
+    const normalizedData = input.data === void 0 ? void 0 : toCanonicalJsonValue(input.data);
+    const normalizedError = input.error === void 0 ? void 0 : normalizeOpensteerError(input.error);
     const artifacts = input.artifacts === void 0 ? void 0 : await Promise.all(
       input.artifacts.manifests.map(async (manifest) => {
         const reference = await root.artifacts.toProtocolArtifactReference(
@@ -28745,19 +29363,56 @@ var OpensteerSessionRuntime = class {
         return reference;
       })
     );
-    await root.traces.append(runId, {
+    const traceEntry = await root.traces.append(runId, {
       operation: input.operation,
       outcome: input.outcome,
       startedAt: input.startedAt,
       completedAt: input.completedAt,
       ...input.context === void 0 ? {} : { context: input.context },
-      ...input.events === void 0 ? {} : { events: input.events },
+      ...stepEvents === void 0 ? {} : { events: stepEvents },
       ...artifacts === void 0 ? {} : { artifacts },
-      ...input.data === void 0 ? {} : { data: toCanonicalJsonValue(input.data) },
-      ...input.error === void 0 ? {} : {
-        error: normalizeOpensteerError(input.error)
+      ...normalizedData === void 0 ? {} : { data: normalizedData },
+      ...normalizedError === void 0 ? {} : {
+        error: normalizedError
       }
     });
+    const observationSession = await this.ensureObservationSession().catch(() => void 0);
+    if (observationSession === void 0 || this.observationConfig.profile === "off") {
+      return;
+    }
+    const observationArtifactIds = input.artifacts === void 0 ? void 0 : (await Promise.allSettled(
+      input.artifacts.manifests.map(async (manifest) => {
+        const artifact = await observationSession.writeArtifact({
+          artifactId: manifest.artifactId,
+          kind: observationArtifactKindFromManifest(manifest.kind),
+          createdAt: manifest.createdAt,
+          context: manifest.scope,
+          mediaType: manifest.mediaType,
+          byteLength: manifest.byteLength,
+          sha256: manifest.sha256,
+          opensteerArtifactId: manifest.artifactId,
+          storageKey: manifestToExternalBinaryLocation(root.rootPath, manifest).uri
+        });
+        return artifact.artifactId;
+      })
+    )).flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+    const observationEvents = buildObservationEventsFromTrace({
+      traceId: traceEntry.traceId,
+      stepId: traceEntry.stepId,
+      operation: input.operation,
+      outcome: input.outcome,
+      startedAt: input.startedAt,
+      completedAt: input.completedAt,
+      ...input.context === void 0 ? {} : { context: input.context },
+      ...stepEvents === void 0 ? {} : { events: stepEvents },
+      ...normalizedData === void 0 ? {} : { data: normalizedData },
+      ...normalizedError === void 0 ? {} : { error: normalizedError },
+      ...observationArtifactIds === void 0 ? {} : { artifactIds: observationArtifactIds },
+      profile: this.observationConfig.profile
+    });
+    if (observationEvents.length > 0) {
+      await observationSession.appendBatch(observationEvents).catch(() => void 0);
+    }
   }
   async cleanupSessionResources(engine, pageRef, sessionRef) {
     if (pageRef !== void 0) {
@@ -28769,6 +29424,7 @@ var OpensteerSessionRuntime = class {
   }
   async resetRuntimeState(options) {
     const engine = this.engine;
+    const observations = this.observations;
     this.networkHistory.clear();
     this.sessionRef = void 0;
     this.pageRef = void 0;
@@ -28777,20 +29433,140 @@ var OpensteerSessionRuntime = class {
     this.computer = void 0;
     this.extractionDescriptors = void 0;
     this.engine = void 0;
+    this.observations = void 0;
+    this.pendingOperationEventCaptures.length = 0;
+    await observations?.close("runtime_reset").catch(() => void 0);
     if (options.disposeEngine && this.ownsEngine && engine?.dispose) {
       await engine.dispose();
     }
     this.ownsEngine = false;
   }
+  async ensureObservationSession() {
+    if (this.observationConfig.profile === "off") {
+      return void 0;
+    }
+    if (this.observations !== void 0) {
+      return this.observations;
+    }
+    const observationSessionId = this.resolveObservationSessionId();
+    if (observationSessionId === void 0) {
+      return void 0;
+    }
+    const sink = this.injectedObservationSink ?? (await this.ensureRoot()).observations;
+    this.observations = await sink.openSession({
+      sessionId: observationSessionId,
+      openedAt: Date.now(),
+      config: this.observationConfig
+    });
+    return this.observations;
+  }
+  resolveObservationSessionId() {
+    return this.observationSessionId ?? this.sessionRef;
+  }
   runWithOperationTimeout(operation, callback, options = {}) {
-    return runWithPolicyTimeout(
-      this.policy.timeout,
-      {
-        operation,
-        ...options.signal === void 0 ? {} : { signal: options.signal }
-      },
-      callback
-    );
+    const existingCollector = this.operationEventStorage.getStore();
+    if (existingCollector !== void 0) {
+      return runWithPolicyTimeout(
+        this.policy.timeout,
+        {
+          operation,
+          ...options.signal === void 0 ? {} : { signal: options.signal }
+        },
+        callback
+      );
+    }
+    const collector = [];
+    const startedAt = Date.now();
+    return this.operationEventStorage.run(collector, async () => {
+      try {
+        return await runWithPolicyTimeout(
+          this.policy.timeout,
+          {
+            operation,
+            ...options.signal === void 0 ? {} : { signal: options.signal }
+          },
+          callback
+        );
+      } finally {
+        this.recordPendingOperationEventCapture({
+          operation,
+          startedAt,
+          completedAt: Date.now(),
+          events: collector
+        });
+      }
+    });
+  }
+  wrapEngineWithObservationCapture(engine) {
+    return new Proxy(engine, {
+      get: (target, property, receiver) => {
+        const value = Reflect.get(target, property, receiver);
+        if (typeof value !== "function") {
+          return value;
+        }
+        return (...args) => {
+          const result = Reflect.apply(value, target, args);
+          if (!(result instanceof Promise)) {
+            return result;
+          }
+          return result.then((resolved) => {
+            this.captureObservedStepEvents(resolved);
+            return resolved;
+          });
+        };
+      }
+    });
+  }
+  captureObservedStepEvents(value) {
+    const collector = this.operationEventStorage.getStore();
+    if (collector === void 0) {
+      return;
+    }
+    const events = readStepResultEvents(value);
+    if (events === void 0 || events.length === 0) {
+      return;
+    }
+    collector.push(...events);
+  }
+  recordPendingOperationEventCapture(capture) {
+    if (capture.events.length === 0) {
+      return;
+    }
+    this.pendingOperationEventCaptures.push({
+      ...capture,
+      events: [...capture.events]
+    });
+    if (this.pendingOperationEventCaptures.length > PENDING_OPERATION_EVENT_CAPTURE_LIMIT) {
+      this.pendingOperationEventCaptures.splice(
+        0,
+        this.pendingOperationEventCaptures.length - PENDING_OPERATION_EVENT_CAPTURE_LIMIT
+      );
+    }
+  }
+  consumePendingOperationEventCapture(operation, startedAt, completedAt) {
+    for (let index = this.pendingOperationEventCaptures.length - 1; index >= 0; index -= 1) {
+      const capture = this.pendingOperationEventCaptures[index];
+      if (capture === void 0) {
+        continue;
+      }
+      if (capture.operation !== operation) {
+        continue;
+      }
+      if (capture.startedAt < startedAt - PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS || capture.completedAt > completedAt + PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS) {
+        continue;
+      }
+      this.pendingOperationEventCaptures.splice(index, 1);
+      return capture.events;
+    }
+    return void 0;
+  }
+  async drainPendingEngineEvents(context) {
+    const pageRef = context?.pageRef ?? this.pageRef;
+    if (pageRef === void 0 || this.engine === void 0) {
+      return void 0;
+    }
+    const events = await this.engine.drainEvents({ pageRef }).catch(() => []);
+    return events.length > 0 ? events : void 0;
   }
   async navigatePage(input, timeout) {
     const remainingMs = timeout.remainingMs();
@@ -28826,6 +29602,34 @@ function buildRuntimeTraceContext(input) {
 function buildArtifactScope(input) {
   return buildRuntimeTraceContext(input);
 }
+function readStepResultEvents(value) {
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  if (!("events" in value)) {
+    return void 0;
+  }
+  const events = value.events;
+  return Array.isArray(events) ? events : void 0;
+}
+function mergeObservedStepEvents(primary, secondary) {
+  if (primary === void 0 || primary.length === 0) {
+    return secondary === void 0 || secondary.length === 0 ? void 0 : secondary;
+  }
+  if (secondary === void 0 || secondary.length === 0) {
+    return primary;
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const event of primary) {
+    merged.set(event.eventId, event);
+  }
+  for (const event of secondary) {
+    merged.set(event.eventId, event);
+  }
+  return [...merged.values()].sort(
+    (left, right) => (left.timestamp ?? 0) - (right.timestamp ?? 0)
+  );
+}
 function selectLiveQueryPageRef(input, currentPageRef) {
   if (input.pageRef !== void 0) {
     return input.pageRef;
@@ -28857,8 +29661,8 @@ function resolveLiveQueryRequestIds(input, history) {
   if (input.requestId !== void 0) {
     requestIdCandidates.push(/* @__PURE__ */ new Set([input.requestId]));
   }
-  if (input.actionId !== void 0) {
-    requestIdCandidates.push(history.getRequestIdsForActionId(input.actionId));
+  if (input.capture !== void 0) {
+    requestIdCandidates.push(history.getRequestIdsForCapture(input.capture));
   }
   if (input.tag !== void 0) {
     requestIdCandidates.push(history.getRequestIdsForTag(input.tag));
@@ -28905,7 +29709,7 @@ function filterNetworkQueryRecords(records, input) {
     if (input.requestId !== void 0 && record.record.requestId !== input.requestId) {
       return false;
     }
-    if (input.actionId !== void 0 && record.actionId !== input.actionId) {
+    if (input.capture !== void 0 && record.capture !== input.capture) {
       return false;
     }
     if (input.tag !== void 0 && !(record.tags ?? []).includes(input.tag)) {
@@ -29788,12 +30592,12 @@ function extractReverseRuntimeValue(value, pointer) {
   }
   return readDotPath(value, pointer);
 }
-function readDotPath(value, path13) {
-  if (path13.length === 0) {
+function readDotPath(value, path15) {
+  if (path15.length === 0) {
     return value;
   }
   let current = value;
-  for (const segment of path13.split(".").filter((entry) => entry.length > 0)) {
+  for (const segment of path15.split(".").filter((entry) => entry.length > 0)) {
     if (current === null || current === void 0) {
       return void 0;
     }
@@ -30162,7 +30966,7 @@ function normalizeRuntimeErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function runtimeDelay(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function applyBrowserCookiesToTransportRequest(request, cookies) {
   if (cookies.length === 0) {
@@ -30266,7 +31070,7 @@ function parseSetCookieHeader(value, requestUrl) {
   }
   const url = new URL(requestUrl);
   let domain = url.hostname;
-  let path13 = defaultCookiePath(url.pathname);
+  let path15 = defaultCookiePath(url.pathname);
   let secure = url.protocol === "https:";
   let expiresAt;
   const cookieValue = rawValueParts.join("=").trim();
@@ -30279,7 +31083,7 @@ function parseSetCookieHeader(value, requestUrl) {
       continue;
     }
     if (key === "path" && attributeValue.length > 0) {
-      path13 = attributeValue;
+      path15 = attributeValue;
       continue;
     }
     if (key === "secure") {
@@ -30305,7 +31109,7 @@ function parseSetCookieHeader(value, requestUrl) {
       name,
       value: cookieValue,
       domain,
-      path: path13,
+      path: path15,
       secure,
       ...expiresAt === void 0 ? {} : { expiresAt }
     }
@@ -31257,7 +32061,7 @@ async function pollUntilResult(timeout, producer) {
     if (produced !== void 0) {
       return produced;
     }
-    await new Promise((resolve5) => setTimeout(resolve5, 100));
+    await new Promise((resolve4) => setTimeout(resolve4, 100));
   }
 }
 async function getMainFrame(engine, pageRef) {
@@ -31315,9 +32119,167 @@ function toOpensteerResolvedTarget2(target) {
 function normalizeOpensteerError(error) {
   return normalizeThrownOpensteerError(error, "Unknown Opensteer runtime failure");
 }
+function observationArtifactKindFromManifest(kind) {
+  switch (kind) {
+    case "screenshot":
+      return "screenshot";
+    case "dom-snapshot":
+      return "dom-snapshot";
+    case "html-snapshot":
+      return "html-snapshot";
+    default:
+      return "other";
+  }
+}
+function buildObservationEventsFromTrace(input) {
+  const context = normalizeObservationContext(input.context);
+  const baseCorrelationId = input.traceId;
+  const startedEvent = {
+    kind: input.operation === "session.open" || input.operation === "session.close" ? "session" : "operation",
+    phase: "started",
+    createdAt: input.startedAt,
+    correlationId: baseCorrelationId,
+    spanId: input.stepId,
+    ...context === void 0 ? {} : { context },
+    data: {
+      operation: input.operation
+    }
+  };
+  const stepEvents = (input.events ?? []).filter((event) => shouldCaptureObservationStepEvent(event, input.profile)).map((event) => {
+    const eventContext = buildObservationContextFromEvent(event);
+    return {
+      kind: observationKindForStepEvent(event),
+      phase: "occurred",
+      createdAt: event.timestamp,
+      correlationId: baseCorrelationId,
+      parentSpanId: input.stepId,
+      ...eventContext === void 0 ? {} : { context: eventContext },
+      data: stripObservationStepEvent(event),
+      ...event.kind === "page-error" ? {
+        error: {
+          message: event.message,
+          ...event.stack === void 0 ? {} : { details: { stack: event.stack } }
+        }
+      } : {}
+    };
+  });
+  const completedEvent = {
+    kind: input.operation === "session.open" || input.operation === "session.close" ? "session" : "operation",
+    phase: input.outcome === "ok" ? "completed" : "failed",
+    createdAt: input.completedAt,
+    correlationId: baseCorrelationId,
+    spanId: input.stepId,
+    ...context === void 0 ? {} : { context },
+    data: {
+      operation: input.operation,
+      startedAt: input.startedAt,
+      completedAt: input.completedAt,
+      durationMs: input.completedAt - input.startedAt,
+      ...input.data === void 0 ? {} : { output: input.data }
+    },
+    ...input.error === void 0 ? {} : {
+      error: {
+        ...input.error.code === void 0 ? {} : { code: input.error.code },
+        message: input.error.message,
+        ...input.error.retriable === void 0 ? {} : { retriable: input.error.retriable },
+        ...input.error.details === void 0 ? {} : { details: toCanonicalJsonValue(input.error.details) }
+      }
+    },
+    ...input.artifactIds === void 0 || input.artifactIds.length === 0 ? {} : { artifactIds: input.artifactIds }
+  };
+  return [startedEvent, ...stepEvents, completedEvent];
+}
+function buildObservationContextFromEvent(event) {
+  return normalizeObservationContext({
+    sessionRef: event.sessionRef,
+    ...event.pageRef === void 0 ? {} : { pageRef: event.pageRef },
+    ...event.frameRef === void 0 ? {} : { frameRef: event.frameRef },
+    ...event.documentRef === void 0 ? {} : { documentRef: event.documentRef },
+    ...event.documentEpoch === void 0 ? {} : { documentEpoch: event.documentEpoch }
+  });
+}
+function shouldCaptureObservationStepEvent(event, profile) {
+  if (profile === "diagnostic") {
+    return true;
+  }
+  switch (event.kind) {
+    case "page-created":
+    case "popup-opened":
+    case "page-closed":
+    case "page-error":
+      return true;
+    case "console":
+      return event.level === "warn" || event.level === "error";
+    default:
+      return false;
+  }
+}
+function observationKindForStepEvent(event) {
+  switch (event.kind) {
+    case "console":
+      return "console";
+    case "page-error":
+      return "error";
+    case "paused":
+    case "resumed":
+    case "frozen":
+      return "runtime";
+    default:
+      return "page";
+  }
+}
+function stripObservationStepEvent(event) {
+  const {
+    eventId: _eventId,
+    kind,
+    timestamp,
+    sessionRef: _sessionRef,
+    pageRef: _pageRef,
+    frameRef: _frameRef,
+    documentRef: _documentRef,
+    documentEpoch: _documentEpoch,
+    ...rest
+  } = event;
+  return toCanonicalJsonValue({
+    eventKind: kind,
+    timestamp,
+    ...rest
+  });
+}
+function buildMutationCaptureTraceData(diagnostics) {
+  if (diagnostics?.finalizeError === void 0) {
+    return {};
+  }
+  return {
+    networkCapture: {
+      finalizeError: diagnostics.finalizeError
+    }
+  };
+}
 function isIgnorableRuntimeBindingError(error) {
   return isBrowserCoreError(error) && (error.code === "not-found" || error.code === "page-closed" || error.code === "session-closed");
 }
+async function withDetachedTimeoutSignal(timeoutMs, operation) {
+  const controller = new AbortController();
+  const timeoutError = new OpensteerProtocolError(
+    "timeout",
+    `mutation capture finalization exceeded ${String(timeoutMs)}ms timeout`,
+    {
+      details: {
+        policy: "mutation-capture-finalize",
+        budgetMs: timeoutMs
+      }
+    }
+  );
+  const timer = setTimeout(() => {
+    controller.abort(timeoutError);
+  }, timeoutMs);
+  try {
+    return await operation(controller.signal);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function screenshotMediaType(format2) {
   switch (format2) {
     case "png":
@@ -31333,8 +32295,8 @@ function screenshotMediaType(format2) {
 var OpensteerRuntime = class extends OpensteerSessionRuntime {
   constructor(options = {}) {
     const publicWorkspace = normalizeWorkspace2(options.workspace);
-    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path6.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", randomUUID()) : resolveFilesystemWorkspacePath({
-      rootDir: path6.resolve(options.rootDir ?? process.cwd()),
+    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path7.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", randomUUID()) : resolveFilesystemWorkspacePath({
+      rootDir: path7.resolve(options.rootDir ?? process.cwd()),
       workspace: publicWorkspace
     }));
     const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
@@ -31359,14 +32321,17 @@ var OpensteerRuntime = class extends OpensteerSessionRuntime {
         ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
         ...options.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: options.extractionDescriptorStore },
         ...options.registryOverrides === void 0 ? {} : { registryOverrides: options.registryOverrides },
-        cleanupRootOnClose
+        cleanupRootOnClose,
+        ...options.observability === void 0 ? {} : { observability: options.observability },
+        ...options.observationSessionId === void 0 ? {} : { observationSessionId: options.observationSessionId },
+        ...options.observationSink === void 0 ? {} : { observationSink: options.observationSink }
       })
     );
   }
 };
 var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
   constructor(options) {
-    const rootPath = options.rootPath ?? path6.resolve(options.rootDir ?? process.cwd());
+    const rootPath = options.rootPath ?? path7.resolve(options.rootDir ?? process.cwd());
     const cleanupRootOnClose = options.cleanupRootOnClose ?? false;
     const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
     assertSupportedEngineOptions({
@@ -31388,7 +32353,10 @@ var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
         ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
         ...options.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: options.extractionDescriptorStore },
         ...options.registryOverrides === void 0 ? {} : { registryOverrides: options.registryOverrides },
-        cleanupRootOnClose
+        cleanupRootOnClose,
+        ...options.observability === void 0 ? {} : { observability: options.observability },
+        ...options.observationSessionId === void 0 ? {} : { observationSessionId: options.observationSessionId },
+        ...options.observationSink === void 0 ? {} : { observationSink: options.observationSink }
       })
     );
   }
@@ -31414,6 +32382,9 @@ function buildSharedRuntimeOptions(input) {
     ...input.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: input.extractionDescriptorStore },
     ...input.registryOverrides === void 0 ? {} : { registryOverrides: input.registryOverrides },
     cleanupRootOnClose: input.cleanupRootOnClose,
+    ...input.observability === void 0 ? {} : { observability: input.observability },
+    ...input.observationSessionId === void 0 ? {} : { observationSessionId: input.observationSessionId },
+    ...input.observationSink === void 0 ? {} : { observationSink: input.observationSink },
     sessionInfo: {
       provider: {
         mode: "local",
@@ -31476,345 +32447,267 @@ function resolveOpensteerProvider(input = {}) {
   };
 }
 var execFile2 = promisify(execFile);
-var DEFAULT_CAPTURE_TIMEOUT_MS = 3e4;
-var DEFAULT_STOP_TIMEOUT_MS = 15e3;
-var DEVTOOLS_POLL_INTERVAL_MS2 = 50;
-var PROCESS_LIST_MAX_BUFFER_BYTES3 = 16 * 1024 * 1024;
-async function resolveCookieCaptureStrategy(input = {}) {
-  const timeoutMs = input.timeoutMs ?? DEFAULT_CAPTURE_TIMEOUT_MS;
-  if (input.attachEndpoint !== void 0) {
-    if (input.strategy !== void 0 && input.strategy !== "attach") {
-      throw new Error(
-        `Strategy "${input.strategy}" is incompatible with an explicit attach endpoint.`
-      );
-    }
-    return {
-      strategy: "attach",
-      attachEndpoint: input.attachEndpoint,
-      ...input.profileDirectory === void 0 ? {} : { profileDirectory: input.profileDirectory },
-      timeoutMs
-    };
-  }
+var NODE_SQLITE_SPECIFIER2 = `node:${"sqlite"}`;
+var CHROME_EPOCH_OFFSET = 11644473600000000n;
+var CHROME_HMAC_PREFIX_LENGTH = 32;
+async function readBrowserCookies(input = {}) {
   const brand2 = resolveRequestedBrand(input);
-  const executablePath = resolveBrandExecutablePath(brand2, input.executablePath);
   const userDataDir = resolveBrandUserDataDir(brand2, input.userDataDir);
-  const profileDirectory = input.profileDirectory;
-  const attachEndpoint = await resolveReachableAttachEndpoint(userDataDir, timeoutMs);
-  const runningProcess = findBrandProcess(brand2);
-  const autoStrategy = attachEndpoint !== void 0 ? "attach" : runningProcess !== null ? "managed-relaunch" : "headless";
-  const strategy = input.strategy ?? autoStrategy;
-  validateRequestedStrategy({
-    strategy,
-    brand: brand2,
-    ...attachEndpoint === void 0 ? {} : { attachEndpoint },
-    ...runningProcess?.pid === void 0 ? {} : { runningPid: runningProcess.pid }
-  });
-  return {
-    strategy,
-    brandId: brand2.id,
-    brandDisplayName: brand2.displayName,
-    executablePath,
-    userDataDir,
-    ...profileDirectory === void 0 ? {} : { profileDirectory },
-    ...attachEndpoint === void 0 ? {} : { attachEndpoint },
-    ...runningProcess === null ? {} : { runningPid: runningProcess.pid },
-    timeoutMs
-  };
-}
-async function acquireCdpEndpoint(resolved) {
-  if (resolved.strategy === "attach") {
-    if (!resolved.attachEndpoint) {
-      throw new Error("Attach capture requires a debuggable browser endpoint.");
-    }
-    const inspected = await inspectCdpEndpoint({
-      endpoint: resolved.attachEndpoint,
-      timeoutMs: Math.min(2e3, resolved.timeoutMs)
-    });
-    return {
-      strategy: "attach",
-      cdpEndpoint: inspected.endpoint,
-      ...resolved.brandId === void 0 ? {} : { brandId: resolved.brandId },
-      ...resolved.brandDisplayName === void 0 ? {} : { brandDisplayName: resolved.brandDisplayName },
-      ...resolved.userDataDir === void 0 ? {} : { userDataDir: resolved.userDataDir },
-      ...resolved.profileDirectory === void 0 ? {} : { profileDirectory: resolved.profileDirectory },
-      cleanup: async () => void 0
-    };
-  }
-  if (!resolved.brandId || !resolved.brandDisplayName || !resolved.executablePath || !resolved.userDataDir) {
+  const profileDirectory = input.profileDirectory ?? "Default";
+  const cookiesPath = join(userDataDir, profileDirectory, "Cookies");
+  if (!existsSync(cookiesPath)) {
     throw new Error(
-      "Headless cookie capture requires a resolved browser brand, executable, and user-data-dir."
+      `Cookies database not found at "${cookiesPath}". Verify the browser brand, user-data-dir, and profile-directory are correct.`
     );
   }
-  const userDataDir = resolved.userDataDir;
-  if (resolved.strategy === "managed-relaunch") {
-    if (resolved.runningPid === void 0) {
-      throw new Error("Managed relaunch requires a running browser process.");
-    }
-    await gracefullyStopBrowser(
-      getBrowserBrand(resolved.brandId),
-      resolved.runningPid,
-      resolved.timeoutMs
-    );
-  }
-  await clearChromeSingletonEntries(userDataDir);
-  try {
-    const capture = await launchCaptureChrome({
-      brandDisplayName: resolved.brandDisplayName,
-      executablePath: resolved.executablePath,
-      userDataDir,
-      ...resolved.profileDirectory === void 0 ? {} : { profileDirectory: resolved.profileDirectory },
-      timeoutMs: resolved.timeoutMs
-    });
-    return {
-      strategy: resolved.strategy,
-      cdpEndpoint: capture.endpoint,
-      brandId: resolved.brandId,
-      brandDisplayName: resolved.brandDisplayName,
-      userDataDir: resolved.userDataDir,
-      ...resolved.profileDirectory === void 0 ? {} : { profileDirectory: resolved.profileDirectory },
-      cleanup: async () => {
-        await capture.kill().catch(() => void 0);
-        await clearChromeSingletonEntries(userDataDir).catch(() => void 0);
-      }
-    };
-  } catch (error) {
-    await clearChromeSingletonEntries(userDataDir).catch(() => void 0);
-    throw error;
-  }
-}
-async function gracefullyStopBrowser(brand2, pid, timeoutMs = DEFAULT_STOP_TIMEOUT_MS) {
-  if (pid <= 0) {
-    return;
-  }
-  const platformConfig = resolveBrandPlatformConfig(brand2);
-  if (process.platform === "darwin" && platformConfig?.bundleId) {
-    await execFile2(
-      "osascript",
-      ["-e", `tell application id "${platformConfig.bundleId}" to quit`],
-      {
-        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES3
-      }
-    ).catch(() => void 0);
-  } else if (process.platform === "win32") {
-    await execFile2("taskkill", ["/PID", String(pid)], {
-      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES3
-    }).catch(() => void 0);
-  } else {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-    }
-  }
-  if (await waitForProcessExit2(pid, timeoutMs)) {
-    return;
-  }
-  if (process.platform === "win32") {
-    await execFile2("taskkill", ["/F", "/PID", String(pid)], {
-      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES3
-    }).catch(() => void 0);
-  } else {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-  await waitForProcessExit2(pid, Math.min(5e3, timeoutMs));
-}
-async function launchCaptureChrome(input) {
-  const stderrLines = [];
-  const child = spawn(input.executablePath, buildCaptureChromeArgs(input), {
-    detached: process.platform !== "win32",
-    stdio: ["ignore", "ignore", "pipe"]
-  });
-  child.unref();
-  child.stderr?.setEncoding("utf8");
-  child.stderr?.on("data", (chunk) => {
-    stderrLines.push(String(chunk));
-  });
+  const tempDir = await mkdtemp(join(tmpdir(), "opensteer-cookies-"));
   try {
-    const endpoint = await waitForCaptureEndpoint({
-      brandDisplayName: input.brandDisplayName,
-      child,
-      stderrLines,
-      timeoutMs: input.timeoutMs,
-      userDataDir: input.userDataDir
-    });
+    await copyCookiesDatabase(cookiesPath, tempDir);
+    const decryptionKey = await resolveDecryptionKey(brand2.id, userDataDir);
+    const rows = queryAllCookies(join(tempDir, "Cookies"));
+    const cookies = decryptCookieRows(rows, decryptionKey);
     return {
-      endpoint,
-      kill: async () => {
-        await terminateChild(child);
-      }
+      cookies,
+      brandId: brand2.id,
+      brandDisplayName: brand2.displayName,
+      userDataDir,
+      profileDirectory
     };
-  } catch (error) {
-    await terminateChild(child).catch(() => void 0);
-    throw error;
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
-function relaunchBrowserNormally(executablePath) {
-  const child = spawn(executablePath, [], {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-}
 function resolveRequestedBrand(input) {
   if (input.brandId !== void 0) {
     return getBrowserBrand(input.brandId);
   }
-  if (input.userDataDir !== void 0) {
-    const inferred = inferBrandFromUserDataDir(input.userDataDir);
-    if (!inferred) {
-      throw new Error(
-        `Could not infer a browser brand from user-data-dir "${input.userDataDir}". Pass --browser explicitly.`
-      );
-    }
-    return inferred;
-  }
-  if (input.executablePath !== void 0) {
-    const inferred = inferBrandFromExecutablePath(input.executablePath);
-    if (!inferred) {
-      throw new Error(
-        `Could not infer a browser brand from executable path "${input.executablePath}". Pass --browser explicitly.`
-      );
-    }
-    return inferred;
-  }
   const installed = detectInstalledBrowserBrands()[0];
   if (!installed) {
     throw new Error(
-      "No Chromium browser found. Install a supported browser or pass --browser explicitly."
+      "No Chromium browser found. Install a supported browser or pass brandId explicitly."
     );
   }
   return installed.brand;
 }
-async function resolveReachableAttachEndpoint(userDataDir, timeoutMs) {
-  const activePort = readDevToolsActivePort(userDataDir);
-  if (!activePort) {
-    return void 0;
+async function copyCookiesDatabase(cookiesPath, destDir) {
+  await copyFile(cookiesPath, join(destDir, "Cookies"));
+  for (const suffix of ["-wal", "-journal", "-shm"]) {
+    const src = cookiesPath + suffix;
+    if (existsSync(src)) {
+      await copyFile(src, join(destDir, "Cookies" + suffix)).catch(() => void 0);
+    }
   }
+}
+function queryAllCookies(dbPath) {
+  let DatabaseSync;
   try {
-    return (await inspectCdpEndpoint({
-      endpoint: `http://127.0.0.1:${String(activePort.port)}`,
-      timeoutMs: Math.min(2e3, timeoutMs)
-    })).endpoint;
+    ({ DatabaseSync } = __require(NODE_SQLITE_SPECIFIER2));
   } catch {
-    return void 0;
+    throw new Error(
+      "Reading browser cookies requires Node's built-in SQLite support. Use Node 22.5+ or a build with node:sqlite enabled."
+    );
+  }
+  const database = new DatabaseSync(dbPath, { readOnly: true });
+  try {
+    const stmt = database.prepare(
+      `SELECT host_key, name, value, encrypted_value, path,
+              expires_utc, is_secure, is_httponly, samesite, is_persistent
+       FROM cookies`
+    );
+    stmt.setReadBigInts(true);
+    return stmt.all();
+  } finally {
+    database.close();
   }
 }
-function validateRequestedStrategy(input) {
-  if (input.strategy === "attach" && input.attachEndpoint === void 0) {
+async function resolveDecryptionKey(brandId, userDataDir) {
+  if (process.platform === "darwin") {
+    const password = await resolveKeychainPassword(brandId);
+    const key = pbkdf2Sync(password, "saltysalt", 1003, 16, "sha1");
+    return { platform: "darwin", key, algorithm: "aes-128-cbc" };
+  }
+  if (process.platform === "linux") {
+    const key = pbkdf2Sync("peanuts", "saltysalt", 1, 16, "sha1");
+    return { platform: "linux", key, algorithm: "aes-128-cbc" };
+  }
+  if (process.platform === "win32") {
+    const key = await resolveWindowsMasterKey(userDataDir);
+    return { platform: "win32", key, algorithm: "aes-256-gcm" };
+  }
+  throw new Error(`Unsupported platform "${process.platform}" for cookie decryption.`);
+}
+var BRAND_KEYCHAIN_SERVICE = {
+  chrome: "Chrome Safe Storage",
+  "chrome-canary": "Chrome Safe Storage",
+  chromium: "Chromium Safe Storage",
+  brave: "Brave Safe Storage",
+  edge: "Microsoft Edge Safe Storage",
+  vivaldi: "Chrome Safe Storage",
+  helium: "Chrome Safe Storage"
+};
+async function resolveKeychainPassword(brandId) {
+  const service = BRAND_KEYCHAIN_SERVICE[brandId];
+  try {
+    const { stdout } = await execFile2("security", [
+      "find-generic-password",
+      "-s",
+      service,
+      "-w"
+    ]);
+    return stdout.trim();
+  } catch {
     throw new Error(
-      `${input.brand.displayName} is not currently exposing a debuggable CDP endpoint for attach mode.`
+      `Failed to retrieve "${service}" from macOS Keychain. Ensure the browser has been opened at least once and Keychain access is allowed.`
     );
   }
-  if (input.strategy === "headless" && input.runningPid !== void 0) {
+}
+async function resolveWindowsMasterKey(userDataDir) {
+  const localStatePath = join(userDataDir, "Local State");
+  let localState;
+  try {
+    localState = JSON.parse(await readFile(localStatePath, "utf8"));
+  } catch {
     throw new Error(
-      `${input.brand.displayName} is already running. Close it first or use managed-relaunch.`
+      `Failed to read "${localStatePath}". Ensure the browser has been opened at least once.`
     );
   }
-  if (input.strategy === "managed-relaunch" && input.runningPid === void 0) {
+  const encodedKey = localState.os_crypt?.encrypted_key;
+  if (!encodedKey) {
+    throw new Error(`No encrypted key found in "${localStatePath}".`);
+  }
+  const rawKey = Buffer.from(encodedKey, "base64").subarray(5);
+  const psScript = `
+    Add-Type -AssemblyName System.Security
+    $bytes = [byte[]]@(${Array.from(rawKey).join(",")})
+    $decrypted = [System.Security.Cryptography.ProtectedData]::Unprotect($bytes, $null, 'CurrentUser')
+    [Convert]::ToBase64String($decrypted)
+  `;
+  try {
+    const { stdout } = await execFile2("powershell", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      psScript
+    ]);
+    return Buffer.from(stdout.trim(), "base64");
+  } catch {
     throw new Error(
-      `${input.brand.displayName} is not currently running, so managed-relaunch is not available.`
+      "Failed to decrypt browser master key via Windows DPAPI. Ensure you are running as the same user who owns the browser profile."
     );
   }
 }
-function inferBrandFromUserDataDir(userDataDir) {
-  const normalized = normalizePath(userDataDir);
-  return getAllBrowserBrands().find((brand2) => {
-    const config = resolveBrandPlatformConfig(brand2);
-    if (!config) {
-      return false;
+function decryptCookieRows(rows, decryptionKey) {
+  const cookies = [];
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  for (const row of rows) {
+    const name = row.name.trim();
+    const domain = row.host_key.trim();
+    if (!name || !domain) {
+      continue;
     }
-    const defaultDir = normalizePath(config.userDataDir);
-    return normalized === defaultDir || normalized.startsWith(`${defaultDir}/`);
-  });
-}
-function inferBrandFromExecutablePath(executablePath) {
-  const normalized = normalizePath(executablePath);
-  return getAllBrowserBrands().find((brand2) => {
-    const config = resolveBrandPlatformConfig(brand2);
-    if (!config) {
-      return false;
+    const value = decryptCookieValue(row, decryptionKey);
+    if (value === null) {
+      continue;
     }
-    return config.executableCandidates.some(
-      (candidate) => candidate !== null && normalizePath(candidate) === normalized
-    );
-  });
-}
-function buildCaptureChromeArgs(input) {
-  const args = [
-    "--remote-debugging-port=0",
-    "--headless=new",
-    "--no-first-run",
-    "--no-default-browser-check",
-    "--disable-background-networking",
-    "--disable-sync",
-    "--disable-component-update",
-    `--user-data-dir=${input.userDataDir}`
-  ];
-  if (input.profileDirectory !== void 0) {
-    args.push(`--profile-directory=${input.profileDirectory}`);
-  }
-  return args;
-}
-async function waitForCaptureEndpoint(input) {
-  const deadline = Date.now() + input.timeoutMs;
-  while (Date.now() < deadline) {
-    const activePort = readDevToolsActivePort(input.userDataDir);
-    if (activePort) {
-      try {
-        return (await inspectCdpEndpoint({
-          endpoint: `http://127.0.0.1:${String(activePort.port)}`,
-          timeoutMs: Math.min(2e3, input.timeoutMs)
-        })).endpoint;
-      } catch {
-        return `ws://127.0.0.1:${String(activePort.port)}${activePort.webSocketPath}`;
-      }
+    const expiresSeconds = chromeDateToUnixSeconds(row.expires_utc);
+    const isSession = expiresSeconds <= 0;
+    if (!isSession && expiresSeconds < nowSeconds) {
+      continue;
     }
-    if (input.child.exitCode !== null) {
-      break;
+    const sameSite = chromeSameSiteToString(row.samesite);
+    let secure = Number(row.is_secure) === 1;
+    if (sameSite === "None") {
+      secure = true;
     }
-    await sleep4(DEVTOOLS_POLL_INTERVAL_MS2);
+    cookies.push({
+      name,
+      value,
+      domain,
+      path: row.path || "/",
+      secure,
+      httpOnly: Number(row.is_httponly) === 1,
+      ...isSession ? {} : { expires: expiresSeconds },
+      ...sameSite !== void 0 ? { sameSite } : {}
+    });
   }
-  throw new Error(formatCaptureLaunchError(input.brandDisplayName, input.stderrLines));
+  return cookies;
 }
-function formatCaptureLaunchError(brandDisplayName, stderrLines) {
-  const relevantLines = stderrLines.join("").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-  if (relevantLines.length === 0) {
-    return `${brandDisplayName} failed to launch before exposing a DevTools endpoint.`;
+function decryptCookieValue(row, decryptionKey) {
+  if (row.value && row.value.length > 0) {
+    return row.value;
   }
-  const focusedLines = relevantLines.filter(
-    (line) => /(error|fatal|sandbox|namespace|permission|cannot|failed|abort)/i.test(line)
-  );
-  return `${brandDisplayName} failed to launch before exposing a DevTools endpoint.
-${(focusedLines.length > 0 ? focusedLines : relevantLines).slice(-5).join("\n")}`;
+  const encrypted = Buffer.isBuffer(row.encrypted_value) ? row.encrypted_value : Buffer.from(row.encrypted_value);
+  if (encrypted.length === 0) {
+    return "";
+  }
+  const prefix = encrypted.subarray(0, 3).toString("ascii");
+  if (prefix !== "v10" && prefix !== "v11") {
+    return encrypted.toString("utf8");
+  }
+  const ciphertext = encrypted.subarray(3);
+  if (decryptionKey.algorithm === "aes-128-cbc") {
+    return decryptAes128Cbc(ciphertext, decryptionKey.key);
+  }
+  if (decryptionKey.algorithm === "aes-256-gcm") {
+    return decryptAes256Gcm(ciphertext, decryptionKey.key);
+  }
+  return null;
 }
-async function terminateChild(child) {
-  if (child.exitCode !== null) {
-    return;
+function decryptAes128Cbc(ciphertext, key) {
+  try {
+    const iv = Buffer.alloc(16, 32);
+    const decipher = createDecipheriv("aes-128-cbc", key, iv);
+    let decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    if (decrypted.length > CHROME_HMAC_PREFIX_LENGTH && containsNonPrintableAscii(decrypted, CHROME_HMAC_PREFIX_LENGTH)) {
+      decrypted = decrypted.subarray(CHROME_HMAC_PREFIX_LENGTH);
+    }
+    if (containsNonPrintableAscii(decrypted, decrypted.length)) {
+      return null;
+    }
+    return decrypted.toString("utf8");
+  } catch {
+    return null;
   }
+}
+function decryptAes256Gcm(ciphertext, key) {
   try {
-    child.kill("SIGKILL");
+    const nonce = ciphertext.subarray(0, 12);
+    const authTag = ciphertext.subarray(ciphertext.length - 16);
+    const encrypted = ciphertext.subarray(12, ciphertext.length - 16);
+    const decipher = createDecipheriv("aes-256-gcm", key, nonce);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    if (containsNonPrintableAscii(decrypted, decrypted.length)) {
+      return null;
+    }
+    return decrypted.toString("utf8");
   } catch {
-    return;
+    return null;
   }
-  await sleep4(50);
 }
-async function waitForProcessExit2(pid, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!isProcessRunning(pid)) {
+function containsNonPrintableAscii(buffer, length) {
+  const end = Math.min(length, buffer.length);
+  for (let i = 0; i < end; i++) {
+    const byte = buffer[i];
+    if (byte < 32 || byte > 126) {
       return true;
     }
-    await sleep4(50);
   }
-  return !isProcessRunning(pid);
+  return false;
 }
-function normalizePath(value) {
-  return resolve(expandHome(value)).replaceAll("\\", "/").toLowerCase();
+function chromeDateToUnixSeconds(chromeTimestamp) {
+  const ts = BigInt(chromeTimestamp);
+  if (ts <= 0n) {
+    return -1;
+  }
+  return Number((ts - CHROME_EPOCH_OFFSET) / 1000000n);
 }
-async function sleep4(ms) {
-  await new Promise((resolve5) => setTimeout(resolve5, ms));
+function chromeSameSiteToString(value) {
+  const v = Number(value);
+  if (v === 0) return "None";
+  if (v === 1) return "Lax";
+  if (v === 2) return "Strict";
+  return void 0;
 }
 
 // src/cloud/cookie-sync.ts
@@ -31870,14 +32763,14 @@ function toPortableBrowserProfileCookieRecord(cookie) {
   if (!name || !domain) {
     return null;
   }
-  const path13 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
+  const path15 = 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: path13,
+    path: path15,
     secure: cookie.secure,
     httpOnly: cookie.httpOnly,
     ...sameSite === void 0 ? {} : { sameSite },
@@ -31893,114 +32786,48 @@ function normalizeSameSite(value) {
   return void 0;
 }
 
-// src/cloud/portable-cookie-snapshot.ts
-var gzip = promisify(gzip$1);
-async function capturePortableBrowserProfileSnapshot(input = {}) {
-  const attached = input.attachEndpoint ? await inspectCdpEndpoint({
-    endpoint: input.attachEndpoint,
-    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
-  }) : await selectAttachBrowserCandidate({
-    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
-  });
-  const browser = await connectPlaywrightChromiumBrowser({
-    url: attached.endpoint
-  });
-  try {
-    const context = browser.contexts()[0];
-    if (!context) {
-      throw new Error("Attached browser did not expose a default browser context.");
-    }
-    const prepared = prepareBrowserProfileSyncCookies({
-      cookies: await context.cookies(),
-      ...input.domains === void 0 ? {} : { domains: input.domains }
-    });
-    if (prepared.cookies.length === 0) {
-      throw new Error("No syncable cookies found for the selected browser and scope.");
-    }
-    const browserVersion = browser.version();
-    const source = parseSnapshotSource(attached.browser ?? browserVersion);
-    return {
-      version: "portable-cookies-v1",
-      source: {
-        browserFamily: "chromium",
-        ...source.browserName === void 0 ? {} : { browserName: source.browserName },
-        ...source.browserMajor === void 0 ? {} : { browserMajor: source.browserMajor },
-        ...input.browserBrand === void 0 ? {} : { browserBrand: input.browserBrand },
-        ...input.captureMethod === void 0 ? {} : { captureMethod: input.captureMethod },
-        platform: normalizePlatform(process.platform),
-        capturedAt: Date.now()
-      },
-      cookies: prepared.cookies
-    };
-  } finally {
-    await browser.close().catch(() => void 0);
-  }
-}
-async function encodePortableBrowserProfileSnapshot(snapshot) {
-  return gzip(Buffer.from(JSON.stringify(snapshot), "utf8"));
-}
-function parseSnapshotSource(value) {
-  if (!value) {
-    return {};
-  }
-  const trimmed = value.trim();
-  const browserName = trimmed.split("/")[0]?.trim() || void 0;
-  const majorMatch = trimmed.match(/(\d+)/);
-  return {
-    ...browserName === void 0 ? {} : { browserName },
-    ...majorMatch?.[1] === void 0 ? {} : { browserMajor: majorMatch[1] }
-  };
-}
-function normalizePlatform(platform) {
-  if (platform === "darwin") return "macos";
-  if (platform === "win32") return "windows";
-  return platform;
-}
-
 // src/cloud/profile-sync.ts
+var gzip = promisify(gzip$1);
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_POLL_TIMEOUT_MS = 5 * 6e4;
 async function syncBrowserProfileCookies(client, input) {
-  const resolved = await resolveCookieCaptureStrategy({
-    ...input.attachEndpoint === void 0 ? {} : { attachEndpoint: input.attachEndpoint },
+  const result = await readBrowserCookies({
     ...input.brandId === void 0 ? {} : { brandId: input.brandId },
     ...input.userDataDir === void 0 ? {} : { userDataDir: input.userDataDir },
-    ...input.profileDirectory === void 0 ? {} : { profileDirectory: input.profileDirectory },
-    ...input.executablePath === void 0 ? {} : { executablePath: input.executablePath },
-    ...input.strategy === void 0 ? {} : { strategy: input.strategy },
-    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
+    ...input.profileDirectory === void 0 ? {} : { profileDirectory: input.profileDirectory }
   });
-  const shouldRestoreBrowser = (input.restoreBrowser ?? true) && resolved.strategy === "managed-relaunch";
-  let captureSource;
-  try {
-    captureSource = await acquireCdpEndpoint(resolved);
-    const snapshot = await capturePortableBrowserProfileSnapshot({
-      attachEndpoint: captureSource.cdpEndpoint,
-      ...captureSource.brandId === void 0 ? {} : { browserBrand: captureSource.brandId },
-      captureMethod: captureSource.strategy,
-      ...input.domains === void 0 ? {} : { domains: input.domains },
-      ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
-    });
-    const payload = await encodePortableBrowserProfileSnapshot(snapshot);
-    const created = await client.createBrowserProfileImport({
-      profileId: input.profileId
-    });
-    if (payload.length > created.maxUploadBytes) {
-      throw new Error(
-        `Compressed cookie snapshot is ${String(payload.length)} bytes, exceeding the ${String(created.maxUploadBytes)} byte upload limit.`
-      );
-    }
-    const uploaded = await client.uploadBrowserProfileImportPayload({
-      uploadUrl: created.uploadUrl,
-      payload
-    });
-    return uploaded.status === "ready" ? uploaded : waitForBrowserProfileImport(client, created.importId);
-  } finally {
-    await captureSource?.cleanup().catch(() => void 0);
-    if (shouldRestoreBrowser && resolved.executablePath !== void 0) {
-      relaunchBrowserNormally(resolved.executablePath);
-    }
+  const prepared = prepareBrowserProfileSyncCookies({
+    cookies: result.cookies,
+    ...input.domains === void 0 ? {} : { domains: input.domains }
+  });
+  if (prepared.cookies.length === 0) {
+    throw new Error("No syncable cookies found for the selected browser and scope.");
+  }
+  const snapshot = {
+    version: "portable-cookies-v1",
+    source: {
+      browserFamily: "chromium",
+      browserBrand: result.brandId,
+      captureMethod: "sqlite",
+      platform: normalizePlatform(process.platform),
+      capturedAt: Date.now()
+    },
+    cookies: prepared.cookies
+  };
+  const payload = await gzip(Buffer.from(JSON.stringify(snapshot), "utf8"));
+  const created = await client.createBrowserProfileImport({
+    profileId: input.profileId
+  });
+  if (payload.length > created.maxUploadBytes) {
+    throw new Error(
+      `Compressed cookie snapshot is ${String(payload.length)} bytes, exceeding the ${String(created.maxUploadBytes)} byte upload limit.`
+    );
   }
+  const uploaded = await client.uploadBrowserProfileImportPayload({
+    uploadUrl: created.uploadUrl,
+    payload
+  });
+  return uploaded.status === "ready" ? uploaded : waitForBrowserProfileImport(client, created.importId);
 }
 async function waitForBrowserProfileImport(client, importId) {
   const deadline = Date.now() + DEFAULT_POLL_TIMEOUT_MS;
@@ -32012,12 +32839,17 @@ async function waitForBrowserProfileImport(client, importId) {
     if (current.status === "failed") {
       throw new Error(current.error ?? "Browser profile sync failed.");
     }
-    await sleep5(DEFAULT_POLL_INTERVAL_MS);
+    await sleep4(DEFAULT_POLL_INTERVAL_MS);
   }
   throw new Error(`Timed out waiting for browser profile sync "${importId}" to finish.`);
 }
-async function sleep5(ms) {
-  await new Promise((resolve5) => setTimeout(resolve5, ms));
+function normalizePlatform(platform) {
+  if (platform === "darwin") return "macos";
+  if (platform === "win32") return "windows";
+  return platform;
+}
+async function sleep4(ms) {
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 // src/cloud/client.ts
@@ -32037,7 +32869,8 @@ var OpensteerCloudClient = class {
         ...input.name === void 0 ? {} : { name: input.name },
         ...input.browser === void 0 ? {} : { browser: input.browser },
         ...input.context === void 0 ? {} : { context: input.context },
-        ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile }
+        ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile },
+        ...input.observability === void 0 ? {} : { observability: input.observability }
       }
     });
     return await response.json();
@@ -32215,8 +33048,8 @@ var OpensteerCloudClient = class {
   }
 };
 function delay(ms) {
-  return new Promise((resolve5) => {
-    setTimeout(resolve5, ms);
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
   });
 }
 function wrapCloudFetchError(error, input) {
@@ -32239,17 +33072,17 @@ function wrapCloudFetchError(error, input) {
 function resolveCloudConfig(input = {}) {
   const provider = resolveOpensteerProvider({
     ...input.provider === void 0 ? {} : { provider: input.provider },
-    ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
+    ...input.environment?.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: input.environment.OPENSTEER_PROVIDER }
   });
   if (provider.mode !== "cloud") {
     return void 0;
   }
   const cloudProvider = input.provider?.mode === "cloud" ? input.provider : void 0;
-  const apiKey = cloudProvider?.apiKey ?? process.env.OPENSTEER_API_KEY;
+  const apiKey = cloudProvider?.apiKey ?? input.environment?.OPENSTEER_API_KEY;
   if (!apiKey || apiKey.trim().length === 0) {
     throw new Error("provider=cloud requires OPENSTEER_API_KEY or provider.apiKey.");
   }
-  const baseUrl = cloudProvider?.baseUrl ?? process.env.OPENSTEER_BASE_URL;
+  const baseUrl = cloudProvider?.baseUrl ?? input.environment?.OPENSTEER_BASE_URL;
   if (!baseUrl || baseUrl.trim().length === 0) {
     throw new Error("provider=cloud requires OPENSTEER_BASE_URL or provider.baseUrl.");
   }
@@ -32351,9 +33184,9 @@ var OpensteerCloudAutomationClient = class {
       sentAt: Date.now(),
       ...input === void 0 ? {} : { input }
     };
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve4, reject) => {
       this.pending.set(requestId, {
-        resolve: (value) => resolve5(value),
+        resolve: (value) => resolve4(value),
         reject
       });
       try {
@@ -32416,8 +33249,8 @@ var OpensteerCloudAutomationClient = class {
       pending.reject(new Error(`automation connection closed before ${requestId} completed`));
     }
     this.pending.clear();
-    await new Promise((resolve5) => {
-      socket.once("close", () => resolve5());
+    await new Promise((resolve4) => {
+      socket.once("close", () => resolve4());
       socket.close();
     }).catch(() => void 0);
   }
@@ -32459,8 +33292,8 @@ var OpensteerCloudAutomationClient = class {
       }
       this.pending.clear();
     });
-    await new Promise((resolve5, reject) => {
-      socket.once("open", () => resolve5());
+    await new Promise((resolve4, reject) => {
+      socket.once("open", () => resolve4());
       socket.once("error", reject);
     });
     this.send({
@@ -32801,6 +33634,7 @@ var CloudSessionProxy = class {
   workspace;
   cleanupRootOnClose;
   cloud;
+  observability;
   sessionId;
   sessionBaseUrl;
   client;
@@ -32809,8 +33643,9 @@ var CloudSessionProxy = class {
   constructor(cloud, options = {}) {
     this.cloud = cloud;
     this.workspace = options.workspace;
-    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path6.join(tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${randomUUID()}`) : resolveFilesystemWorkspacePath({
-      rootDir: path6.resolve(options.rootDir ?? process.cwd()),
+    this.observability = options.observability;
+    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7.join(tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${randomUUID()}`) : resolveFilesystemWorkspacePath({
+      rootDir: path7.resolve(options.rootDir ?? process.cwd()),
       workspace: this.workspace
     }));
     this.cleanupRootOnClose = options.cleanupRootOnClose ?? this.workspace === void 0;
@@ -33153,6 +33988,7 @@ var CloudSessionProxy = class {
       ...this.workspace === void 0 ? {} : { name: this.workspace },
       ...input.launch === void 0 ? {} : { browser: input.launch },
       ...input.context === void 0 ? {} : { context: input.context },
+      ...this.observability === void 0 ? {} : { observability: this.observability },
       ...resolveCloudBrowserProfile(this.cloud, input) === void 0 ? {} : { browserProfile: resolveCloudBrowserProfile(this.cloud, input) }
     });
     const record = {
@@ -33250,16 +34086,17 @@ function isMissingCloudSessionError(error) {
 
 // src/sdk/runtime-resolution.ts
 function resolveOpensteerRuntimeConfig(input = {}) {
+  const environment = input.environment ?? process.env;
   const provider = resolveOpensteerProvider({
     ...input.provider === void 0 ? {} : { provider: input.provider },
-    ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
+    ...environment.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: environment.OPENSTEER_PROVIDER }
   });
   if (provider.mode === "cloud") {
     return {
       provider,
       cloud: resolveCloudConfig({
         ...input.provider === void 0 ? {} : { provider: input.provider },
-        ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
+        environment
       })
     };
   }
@@ -33270,7 +34107,7 @@ function createOpensteerSemanticRuntime(input = {}) {
   const engine = input.engine ?? runtimeOptions.engineName ?? DEFAULT_OPENSTEER_ENGINE;
   const config = resolveOpensteerRuntimeConfig({
     ...input.provider === void 0 ? {} : { provider: input.provider },
-    ...process.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process.env.OPENSTEER_PROVIDER }
+    ...input.environment === void 0 ? {} : { environment: input.environment }
   });
   assertProviderSupportsEngine(config.provider.mode, engine);
   if (config.provider.mode === "cloud") {
@@ -33278,7 +34115,8 @@ function createOpensteerSemanticRuntime(input = {}) {
       ...runtimeOptions.rootDir === void 0 ? {} : { rootDir: runtimeOptions.rootDir },
       ...runtimeOptions.rootPath === void 0 ? {} : { rootPath: runtimeOptions.rootPath },
       ...runtimeOptions.workspace === void 0 ? {} : { workspace: runtimeOptions.workspace },
-      ...runtimeOptions.cleanupRootOnClose === void 0 ? {} : { cleanupRootOnClose: runtimeOptions.cleanupRootOnClose }
+      ...runtimeOptions.cleanupRootOnClose === void 0 ? {} : { cleanupRootOnClose: runtimeOptions.cleanupRootOnClose },
+      ...runtimeOptions.observability === void 0 ? {} : { observability: runtimeOptions.observability }
     });
   }
   return new OpensteerRuntime({
@@ -33286,7 +34124,109 @@ function createOpensteerSemanticRuntime(input = {}) {
     engineName: engine
   });
 }
+var ENV_FILENAMES = [".env", ".env.local"];
+var OPENSTEER_ENV_PREFIX = "OPENSTEER_";
+var opensteerEnvironmentCache = /* @__PURE__ */ new Map();
+function resolveOpensteerEnvironment(cwd = process.cwd(), baseEnv = process.env) {
+  const resolvedCwd = path7.resolve(cwd);
+  const signature = buildEnvironmentSignature(baseEnv, isOpensteerEnvironmentKey);
+  const cached = opensteerEnvironmentCache.get(resolvedCwd);
+  if (cached && cached.signature === signature) {
+    return { ...cached.values };
+  }
+  const resolved = resolveEnvironmentFiles(resolvedCwd, baseEnv, isOpensteerEnvironmentKey);
+  opensteerEnvironmentCache.set(resolvedCwd, {
+    signature,
+    values: { ...resolved }
+  });
+  return { ...resolved };
+}
+function loadEnvironment(cwd = process.cwd()) {
+  const resolved = resolveEnvironmentFiles(path7.resolve(cwd), process.env);
+  for (const [key, value] of Object.entries(resolved)) {
+    process.env[key] = value;
+  }
+}
+function collectDirectories(cwd) {
+  const directories = [];
+  let current = path7.resolve(cwd);
+  for (; ; ) {
+    directories.unshift(current);
+    const parent = path7.dirname(current);
+    if (parent === current) {
+      return directories;
+    }
+    current = parent;
+  }
+}
+function parseEnvFile(contents) {
+  const parsed = {};
+  for (const rawLine of contents.split(/\r?\n/u)) {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const line = trimmed.startsWith("export ") ? trimmed.slice("export ".length) : trimmed;
+    const separatorIndex = line.indexOf("=");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key)) {
+      continue;
+    }
+    const rawValue = line.slice(separatorIndex + 1).trim();
+    parsed[key] = parseEnvValue(rawValue);
+  }
+  return parsed;
+}
+function parseEnvValue(rawValue) {
+  if (rawValue.length >= 2 && rawValue.startsWith('"') && rawValue.endsWith('"')) {
+    return rawValue.slice(1, -1).replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"');
+  }
+  if (rawValue.length >= 2 && rawValue.startsWith("'") && rawValue.endsWith("'")) {
+    return rawValue.slice(1, -1);
+  }
+  return rawValue.replace(/\s+#.*$/u, "").trimEnd();
+}
+function resolveEnvironmentFiles(cwd, baseEnv, predicate) {
+  const resolved = collectEnvironment(baseEnv, predicate);
+  const protectedKeys = new Set(Object.keys(resolved));
+  const directories = collectDirectories(cwd);
+  for (const directory of directories) {
+    for (const filename of ENV_FILENAMES) {
+      const filePath = path7.join(directory, filename);
+      if (!existsSync(filePath)) {
+        continue;
+      }
+      const parsed = parseEnvFile(readFileSync(filePath, "utf8"));
+      for (const [key, value] of Object.entries(parsed)) {
+        if (predicate && !predicate(key) || protectedKeys.has(key)) {
+          continue;
+        }
+        resolved[key] = value;
+      }
+    }
+  }
+  return resolved;
+}
+function collectEnvironment(baseEnv, predicate) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(baseEnv)) {
+    if (predicate && !predicate(key) || value === void 0) {
+      continue;
+    }
+    resolved[key] = value;
+  }
+  return resolved;
+}
+function buildEnvironmentSignature(baseEnv, predicate) {
+  return Object.entries(baseEnv).filter(([key, value]) => predicate(key) && value !== void 0).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, value]) => `${key}=${value}`).join("\n");
+}
+function isOpensteerEnvironmentKey(key) {
+  return key.startsWith(OPENSTEER_ENV_PREFIX);
+}
 
-export { CloudSessionProxy, DEFAULT_OPENSTEER_ENGINE, DEFERRED_MATCH_ATTR_KEYS, ElementPathError, MATCH_ATTRIBUTE_PRIORITY, OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL, OPENSTEER_ENGINE_NAMES, OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT, OPENSTEER_FILESYSTEM_WORKSPACE_VERSION, OpensteerAttachAmbiguousError, OpensteerBrowserManager, OpensteerCloudClient, OpensteerRuntime, OpensteerSessionRuntime2 as OpensteerSessionRuntime, STABLE_PRIMARY_ATTR_KEYS, assertProviderSupportsEngine, buildArrayFieldPathCandidates, buildDomDescriptorKey, buildDomDescriptorPayload, buildDomDescriptorVersion, buildPathCandidates, buildPathSelectorHint, buildSegmentSelector, clearPersistedSessionRecord, cloneElementPath, cloneReplayElementPath, cloneStructuralElementAnchor, createDomRuntime, createFilesystemOpensteerWorkspace, createOpensteerExtractionDescriptorStore, createOpensteerSemanticRuntime, defaultFallbackPolicy, defaultPolicy, defaultRetryPolicy, defaultSettlePolicy, defaultTimeoutPolicy, delayWithSignal, discoverLocalCdpBrowsers, dispatchSemanticOperation, hashDomDescriptorDescription, inspectCdpEndpoint, isCurrentUrlField, isProcessRunning, isValidCssAttributeKey, listLocalChromeProfiles, normalizeExtractedValue, normalizeOpensteerEngineName, normalizeOpensteerProviderMode, normalizeWorkspaceId, parseDomDescriptorRecord, parseExtractionDescriptorRecord, pathExists, readPersistedCloudSessionRecord, readPersistedLocalBrowserSessionRecord, readPersistedSessionRecord, resolveCloudConfig, resolveCloudSessionRecordPath, resolveDomActionBridge, resolveExtractedValueInContext, resolveFilesystemWorkspacePath, resolveLiveSessionRecordPath, resolveLocalSessionRecordPath, resolveOpensteerEngineName, resolveOpensteerProvider, resolveOpensteerRuntimeConfig, runWithPolicyTimeout, sanitizeElementPath, sanitizeReplayElementPath, sanitizeStructuralElementAnchor, settleWithPolicy, shouldKeepAttributeForPath, writePersistedSessionRecord };
-//# sourceMappingURL=chunk-IAA57HNW.js.map
-//# sourceMappingURL=chunk-IAA57HNW.js.map
+export { CloudSessionProxy, DEFAULT_OPENSTEER_ENGINE, DEFERRED_MATCH_ATTR_KEYS, ElementPathError, MATCH_ATTRIBUTE_PRIORITY, OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL, OPENSTEER_ENGINE_NAMES, OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT, OPENSTEER_FILESYSTEM_WORKSPACE_VERSION, OpensteerAttachAmbiguousError, OpensteerBrowserManager, OpensteerCloudClient, OpensteerRuntime, OpensteerSessionRuntime2 as OpensteerSessionRuntime, STABLE_PRIMARY_ATTR_KEYS, assertProviderSupportsEngine, buildArrayFieldPathCandidates, buildDomDescriptorKey, buildDomDescriptorPayload, buildDomDescriptorVersion, buildPathCandidates, buildPathSelectorHint, buildSegmentSelector, clearPersistedSessionRecord, cloneElementPath, cloneReplayElementPath, cloneStructuralElementAnchor, createArtifactStore, createDomRuntime, createFilesystemOpensteerWorkspace, createObservationStore, createOpensteerExtractionDescriptorStore, createOpensteerSemanticRuntime, defaultFallbackPolicy, defaultPolicy, defaultRetryPolicy, defaultSettlePolicy, defaultTimeoutPolicy, delayWithSignal, discoverLocalCdpBrowsers, dispatchSemanticOperation, hashDomDescriptorDescription, inspectCdpEndpoint, isCurrentUrlField, isProcessRunning, isValidCssAttributeKey, listLocalChromeProfiles, loadEnvironment, manifestToExternalBinaryLocation, normalizeExtractedValue, normalizeObservabilityConfig, normalizeOpensteerEngineName, normalizeOpensteerProviderMode, normalizeWorkspaceId, parseDomDescriptorRecord, parseExtractionDescriptorRecord, pathExists, readPersistedCloudSessionRecord, readPersistedLocalBrowserSessionRecord, readPersistedSessionRecord, resolveCloudConfig, resolveCloudSessionRecordPath, resolveDomActionBridge, resolveExtractedValueInContext, resolveFilesystemWorkspacePath, resolveLiveSessionRecordPath, resolveLocalSessionRecordPath, resolveOpensteerEngineName, resolveOpensteerEnvironment, resolveOpensteerProvider, resolveOpensteerRuntimeConfig, runWithPolicyTimeout, sanitizeElementPath, sanitizeReplayElementPath, sanitizeStructuralElementAnchor, settleWithPolicy, shouldKeepAttributeForPath, writePersistedSessionRecord };
+//# sourceMappingURL=chunk-RO6WAWWG.js.map
+//# sourceMappingURL=chunk-RO6WAWWG.js.map