@opensteer/protocol 0.7.5 → 0.7.7

package/dist/index.cjs

@@ -882,6 +882,145 @@ var opensteerCaptchaSolveOutputSchema = objectSchema(
   }
 );
 
+// src/storage.ts
+var jsonUnknownSchema = {};
+var cookieSameSiteSchema = enumSchema(["strict", "lax", "none"], {
+  title: "CookieSameSite"
+});
+var cookiePrioritySchema = enumSchema(["low", "medium", "high"], {
+  title: "CookiePriority"
+});
+var cookieRecordSchema = objectSchema(
+  {
+    sessionRef: sessionRefSchema,
+    name: stringSchema(),
+    value: stringSchema(),
+    domain: stringSchema(),
+    path: stringSchema(),
+    secure: {
+      type: "boolean"
+    },
+    httpOnly: {
+      type: "boolean"
+    },
+    sameSite: cookieSameSiteSchema,
+    priority: cookiePrioritySchema,
+    partitionKey: stringSchema(),
+    session: {
+      type: "boolean"
+    },
+    expiresAt: {
+      type: ["number", "null"]
+    }
+  },
+  {
+    title: "CookieRecord",
+    required: ["sessionRef", "name", "value", "domain", "path", "secure", "httpOnly", "session"]
+  }
+);
+var storageEntrySchema = objectSchema(
+  {
+    key: stringSchema(),
+    value: stringSchema()
+  },
+  {
+    title: "StorageEntry",
+    required: ["key", "value"]
+  }
+);
+var indexedDbRecordSchema = objectSchema(
+  {
+    key: jsonUnknownSchema,
+    primaryKey: jsonUnknownSchema,
+    value: jsonUnknownSchema
+  },
+  {
+    title: "IndexedDbRecord",
+    required: ["key", "value"]
+  }
+);
+var indexedDbIndexSnapshotSchema = objectSchema(
+  {
+    name: stringSchema(),
+    keyPath: {
+      oneOf: [stringSchema(), arraySchema(stringSchema())]
+    },
+    multiEntry: {
+      type: "boolean"
+    },
+    unique: {
+      type: "boolean"
+    }
+  },
+  {
+    title: "IndexedDbIndexSnapshot",
+    required: ["name", "multiEntry", "unique"]
+  }
+);
+var indexedDbObjectStoreSnapshotSchema = objectSchema(
+  {
+    name: stringSchema(),
+    keyPath: {
+      oneOf: [stringSchema(), arraySchema(stringSchema())]
+    },
+    autoIncrement: {
+      type: "boolean"
+    },
+    indexes: arraySchema(indexedDbIndexSnapshotSchema),
+    records: arraySchema(indexedDbRecordSchema)
+  },
+  {
+    title: "IndexedDbObjectStoreSnapshot",
+    required: ["name", "autoIncrement", "indexes", "records"]
+  }
+);
+var indexedDbDatabaseSnapshotSchema = objectSchema(
+  {
+    name: stringSchema(),
+    version: numberSchema(),
+    objectStores: arraySchema(indexedDbObjectStoreSnapshotSchema)
+  },
+  {
+    title: "IndexedDbDatabaseSnapshot",
+    required: ["name", "version", "objectStores"]
+  }
+);
+var storageOriginSnapshotSchema = objectSchema(
+  {
+    origin: stringSchema(),
+    localStorage: arraySchema(storageEntrySchema),
+    indexedDb: arraySchema(indexedDbDatabaseSnapshotSchema)
+  },
+  {
+    title: "StorageOriginSnapshot",
+    required: ["origin", "localStorage"]
+  }
+);
+var sessionStorageSnapshotSchema = objectSchema(
+  {
+    pageRef: pageRefSchema,
+    frameRef: frameRefSchema,
+    origin: stringSchema(),
+    entries: arraySchema(storageEntrySchema)
+  },
+  {
+    title: "SessionStorageSnapshot",
+    required: ["pageRef", "frameRef", "origin", "entries"]
+  }
+);
+var storageSnapshotSchema = objectSchema(
+  {
+    sessionRef: sessionRefSchema,
+    capturedAt: integerSchema({ minimum: 0 }),
+    origins: arraySchema(storageOriginSnapshotSchema),
+    sessionStorage: arraySchema(sessionStorageSnapshotSchema)
+  },
+  {
+    title: "StorageSnapshot",
+    required: ["sessionRef", "capturedAt", "origins"]
+  }
+);
+
 // src/requests.ts
 var opensteerRequestScalarSchema = oneOfSchema(
   [stringSchema(), { type: "number" }, { type: "boolean" }],
@@ -1533,24 +1672,294 @@ var opensteerNetworkQueryInputSchema = objectSchema(
     hostname: stringSchema({ minLength: 1 }),
     path: stringSchema({ minLength: 1 }),
     method: stringSchema({ minLength: 1 }),
-    status: stringSchema({ minLength: 1 }),
+    status: oneOfSchema([
+      integerSchema({ minimum: 100, maximum: 599 }),
+      stringSchema({ minLength: 1 })
+    ]),
     resourceType: networkResourceTypeSchema,
     includeBodies: { type: "boolean" },
-    limit: integerSchema({ minimum: 1, maximum: 200 })
+    json: { type: "boolean" },
+    before: stringSchema({ minLength: 1 }),
+    after: stringSchema({ minLength: 1 }),
+    limit: integerSchema({ minimum: 1, maximum: 1e3 })
   },
   {
     title: "OpensteerNetworkQueryInput"
   }
 );
+var opensteerGraphqlSummarySchema = objectSchema(
+  {
+    operationType: enumSchema(["query", "mutation", "subscription", "unknown"]),
+    operationName: stringSchema({ minLength: 1 }),
+    persisted: { type: "boolean" }
+  },
+  {
+    title: "OpensteerGraphqlSummary"
+  }
+);
+var opensteerNetworkBodySummarySchema = objectSchema(
+  {
+    bytes: integerSchema({ minimum: 0 }),
+    contentType: stringSchema({ minLength: 1 }),
+    streaming: { type: "boolean" }
+  },
+  {
+    title: "OpensteerNetworkBodySummary"
+  }
+);
+var opensteerNetworkSummaryRecordSchema = objectSchema(
+  {
+    recordId: stringSchema({ minLength: 1 }),
+    capture: stringSchema({ minLength: 1 }),
+    savedAt: integerSchema({ minimum: 0 }),
+    kind: enumSchema(["http", "websocket", "event-stream"]),
+    method: stringSchema({ minLength: 1 }),
+    status: integerSchema({ minimum: 100, maximum: 599 }),
+    resourceType: networkResourceTypeSchema,
+    url: stringSchema({ minLength: 1 }),
+    request: opensteerNetworkBodySummarySchema,
+    response: opensteerNetworkBodySummarySchema,
+    graphql: opensteerGraphqlSummarySchema,
+    websocket: objectSchema(
+      {
+        subprotocol: stringSchema({ minLength: 1 })
+      },
+      {
+        title: "OpensteerWebsocketSummary"
+      }
+    )
+  },
+  {
+    title: "OpensteerNetworkSummaryRecord",
+    required: ["recordId", "kind", "method", "resourceType", "url"]
+  }
+);
 var opensteerNetworkQueryOutputSchema = objectSchema(
   {
-    records: arraySchema(networkQueryRecordSchema)
+    records: arraySchema(opensteerNetworkSummaryRecordSchema)
   },
   {
     title: "OpensteerNetworkQueryOutput",
     required: ["records"]
   }
 );
+var opensteerParsedCookieSchema = objectSchema(
+  {
+    name: stringSchema({ minLength: 1 }),
+    value: stringSchema()
+  },
+  {
+    title: "OpensteerParsedCookie",
+    required: ["name", "value"]
+  }
+);
+var opensteerStructuredBodyPreviewSchema = objectSchema(
+  {
+    contentType: stringSchema({ minLength: 1 }),
+    bytes: integerSchema({ minimum: 0 }),
+    truncated: { type: "boolean" },
+    data: oneOfSchema([jsonValueSchema, stringSchema()]),
+    note: stringSchema()
+  },
+  {
+    title: "OpensteerStructuredBodyPreview",
+    required: ["bytes", "truncated"]
+  }
+);
+var opensteerNetworkRedirectHopSchema = objectSchema(
+  {
+    method: stringSchema({ minLength: 1 }),
+    status: integerSchema({ minimum: 100, maximum: 599 }),
+    url: stringSchema({ minLength: 1 }),
+    location: stringSchema({ minLength: 1 }),
+    setCookie: arraySchema(stringSchema())
+  },
+  {
+    title: "OpensteerNetworkRedirectHop",
+    required: ["method", "url"]
+  }
+);
+var opensteerReplayAttemptSchema = objectSchema(
+  {
+    transport: transportKindSchema,
+    status: integerSchema({ minimum: 100, maximum: 599 }),
+    ok: { type: "boolean" },
+    durationMs: integerSchema({ minimum: 0 }),
+    note: stringSchema(),
+    error: stringSchema()
+  },
+  {
+    title: "OpensteerReplayAttempt",
+    required: ["transport", "ok", "durationMs"]
+  }
+);
+var opensteerNetworkDetailOutputSchema = objectSchema(
+  {
+    recordId: stringSchema({ minLength: 1 }),
+    capture: stringSchema({ minLength: 1 }),
+    savedAt: integerSchema({ minimum: 0 }),
+    summary: opensteerNetworkSummaryRecordSchema,
+    requestHeaders: arraySchema(headerEntrySchema),
+    responseHeaders: arraySchema(headerEntrySchema),
+    cookiesSent: arraySchema(opensteerParsedCookieSchema),
+    requestBody: opensteerStructuredBodyPreviewSchema,
+    responseBody: opensteerStructuredBodyPreviewSchema,
+    graphql: objectSchema(
+      {
+        operationType: enumSchema(["query", "mutation", "subscription", "unknown"]),
+        operationName: stringSchema({ minLength: 1 }),
+        persisted: { type: "boolean" },
+        variables: jsonValueSchema
+      },
+      {
+        title: "OpensteerGraphqlDetail"
+      }
+    ),
+    redirectChain: arraySchema(opensteerNetworkRedirectHopSchema),
+    notes: arraySchema(stringSchema()),
+    transportProbe: objectSchema(
+      {
+        recommended: transportKindSchema,
+        attempts: arraySchema(opensteerReplayAttemptSchema)
+      },
+      {
+        title: "OpensteerTransportProbeResult",
+        required: ["attempts"]
+      }
+    )
+  },
+  {
+    title: "OpensteerNetworkDetailOutput",
+    required: ["recordId", "summary", "requestHeaders", "responseHeaders"]
+  }
+);
+var opensteerNetworkReplayInputSchema = objectSchema(
+  {
+    recordId: stringSchema({ minLength: 1 }),
+    pageRef: pageRefSchema,
+    query: opensteerRequestScalarMapSchema,
+    headers: opensteerRequestScalarMapSchema,
+    body: opensteerRequestBodyInputSchema,
+    variables: jsonValueSchema
+  },
+  {
+    title: "OpensteerNetworkReplayInput",
+    required: ["recordId"]
+  }
+);
+exports.opensteerNetworkReplayOutputSchema = void 0;
+var opensteerSessionFetchTransportSchema = enumSchema(
+  ["auto", "direct", "matched-tls", "page"],
+  {
+    title: "OpensteerSessionFetchTransport"
+  }
+);
+var opensteerSessionFetchInputSchema = objectSchema(
+  {
+    pageRef: pageRefSchema,
+    url: stringSchema({ minLength: 1 }),
+    method: stringSchema({ minLength: 1 }),
+    query: opensteerRequestScalarMapSchema,
+    headers: opensteerRequestScalarMapSchema,
+    body: opensteerRequestBodyInputSchema,
+    transport: opensteerSessionFetchTransportSchema,
+    cookies: { type: "boolean" },
+    followRedirects: { type: "boolean" }
+  },
+  {
+    title: "OpensteerSessionFetchInput",
+    required: ["url"]
+  }
+);
+exports.opensteerSessionFetchOutputSchema = void 0;
+var opensteerCookieQueryInputSchema = objectSchema(
+  {
+    domain: stringSchema({ minLength: 1 })
+  },
+  {
+    title: "OpensteerCookieQueryInput"
+  }
+);
+var opensteerCookieQueryOutputSchema = objectSchema(
+  {
+    domain: stringSchema({ minLength: 1 }),
+    cookies: arraySchema(cookieRecordSchema)
+  },
+  {
+    title: "OpensteerCookieQueryOutput",
+    required: ["cookies"]
+  }
+);
+var opensteerStorageDomainSnapshotSchema = objectSchema(
+  {
+    domain: stringSchema({ minLength: 1 }),
+    localStorage: arraySchema(storageEntrySchema),
+    sessionStorage: arraySchema(storageEntrySchema)
+  },
+  {
+    title: "OpensteerStorageDomainSnapshot",
+    required: ["domain", "localStorage", "sessionStorage"]
+  }
+);
+var opensteerStorageQueryInputSchema = objectSchema(
+  {
+    domain: stringSchema({ minLength: 1 })
+  },
+  {
+    title: "OpensteerStorageQueryInput"
+  }
+);
+var opensteerStorageQueryOutputSchema = objectSchema(
+  {
+    domains: arraySchema(opensteerStorageDomainSnapshotSchema)
+  },
+  {
+    title: "OpensteerStorageQueryOutput",
+    required: ["domains"]
+  }
+);
+var opensteerHiddenFieldSchema = objectSchema(
+  {
+    path: stringSchema({ minLength: 1 }),
+    name: stringSchema({ minLength: 1 }),
+    value: stringSchema()
+  },
+  {
+    title: "OpensteerHiddenField",
+    required: ["path", "name", "value"]
+  }
+);
+var opensteerStateDomainSnapshotSchema = objectSchema(
+  {
+    domain: stringSchema({ minLength: 1 }),
+    cookies: arraySchema(cookieRecordSchema),
+    hiddenFields: arraySchema(opensteerHiddenFieldSchema),
+    localStorage: arraySchema(storageEntrySchema),
+    sessionStorage: arraySchema(storageEntrySchema),
+    globals: recordSchema(jsonValueSchema)
+  },
+  {
+    title: "OpensteerStateDomainSnapshot",
+    required: ["domain", "cookies", "hiddenFields", "localStorage", "sessionStorage"]
+  }
+);
+var opensteerStateQueryInputSchema = objectSchema(
+  {
+    domain: stringSchema({ minLength: 1 })
+  },
+  {
+    title: "OpensteerStateQueryInput"
+  }
+);
+var opensteerStateQueryOutputSchema = objectSchema(
+  {
+    domains: arraySchema(opensteerStateDomainSnapshotSchema)
+  },
+  {
+    title: "OpensteerStateQueryOutput",
+    required: ["domains"]
+  }
+);
 var opensteerNetworkTagInputSchema = objectSchema(
   {
     pageRef: pageRefSchema,
@@ -1786,6 +2195,33 @@ var opensteerRequestResponseResultSchema = objectSchema(
     required: ["url", "status", "statusText", "headers", "redirected"]
   }
 );
+exports.opensteerNetworkReplayOutputSchema = objectSchema(
+  {
+    recordId: stringSchema({ minLength: 1 }),
+    transport: transportKindSchema,
+    attempts: arraySchema(opensteerReplayAttemptSchema),
+    response: opensteerRequestResponseResultSchema,
+    data: oneOfSchema([jsonValueSchema, stringSchema()]),
+    note: stringSchema()
+  },
+  {
+    title: "OpensteerNetworkReplayOutput",
+    required: ["recordId", "attempts"]
+  }
+);
+exports.opensteerSessionFetchOutputSchema = objectSchema(
+  {
+    transport: transportKindSchema,
+    attempts: arraySchema(opensteerReplayAttemptSchema),
+    response: opensteerRequestResponseResultSchema,
+    data: oneOfSchema([jsonValueSchema, stringSchema()]),
+    note: stringSchema()
+  },
+  {
+    title: "OpensteerSessionFetchOutput",
+    required: ["attempts"]
+  }
+);
 var opensteerRequestExecuteOutputSchema = objectSchema(
   {
     plan: objectSchema(
@@ -1842,154 +2278,15 @@ var opensteerRawRequestOutputSchema = objectSchema(
   }
 );
 var opensteerInferRequestPlanInputSchema = objectSchema(
-  {
-    recordId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    transport: transportKindSchema
-  },
-  {
-    title: "OpensteerInferRequestPlanInput",
-    required: ["recordId", "key", "version"]
-  }
-);
-
-// src/storage.ts
-var jsonUnknownSchema = {};
-var cookieSameSiteSchema = enumSchema(["strict", "lax", "none"], {
-  title: "CookieSameSite"
-});
-var cookiePrioritySchema = enumSchema(["low", "medium", "high"], {
-  title: "CookiePriority"
-});
-var cookieRecordSchema = objectSchema(
-  {
-    sessionRef: sessionRefSchema,
-    name: stringSchema(),
-    value: stringSchema(),
-    domain: stringSchema(),
-    path: stringSchema(),
-    secure: {
-      type: "boolean"
-    },
-    httpOnly: {
-      type: "boolean"
-    },
-    sameSite: cookieSameSiteSchema,
-    priority: cookiePrioritySchema,
-    partitionKey: stringSchema(),
-    session: {
-      type: "boolean"
-    },
-    expiresAt: {
-      type: ["number", "null"]
-    }
-  },
-  {
-    title: "CookieRecord",
-    required: ["sessionRef", "name", "value", "domain", "path", "secure", "httpOnly", "session"]
-  }
-);
-var storageEntrySchema = objectSchema(
-  {
-    key: stringSchema(),
-    value: stringSchema()
-  },
-  {
-    title: "StorageEntry",
-    required: ["key", "value"]
-  }
-);
-var indexedDbRecordSchema = objectSchema(
-  {
-    key: jsonUnknownSchema,
-    primaryKey: jsonUnknownSchema,
-    value: jsonUnknownSchema
-  },
-  {
-    title: "IndexedDbRecord",
-    required: ["key", "value"]
-  }
-);
-var indexedDbIndexSnapshotSchema = objectSchema(
-  {
-    name: stringSchema(),
-    keyPath: {
-      oneOf: [stringSchema(), arraySchema(stringSchema())]
-    },
-    multiEntry: {
-      type: "boolean"
-    },
-    unique: {
-      type: "boolean"
-    }
-  },
-  {
-    title: "IndexedDbIndexSnapshot",
-    required: ["name", "multiEntry", "unique"]
-  }
-);
-var indexedDbObjectStoreSnapshotSchema = objectSchema(
-  {
-    name: stringSchema(),
-    keyPath: {
-      oneOf: [stringSchema(), arraySchema(stringSchema())]
-    },
-    autoIncrement: {
-      type: "boolean"
-    },
-    indexes: arraySchema(indexedDbIndexSnapshotSchema),
-    records: arraySchema(indexedDbRecordSchema)
-  },
-  {
-    title: "IndexedDbObjectStoreSnapshot",
-    required: ["name", "autoIncrement", "indexes", "records"]
-  }
-);
-var indexedDbDatabaseSnapshotSchema = objectSchema(
-  {
-    name: stringSchema(),
-    version: numberSchema(),
-    objectStores: arraySchema(indexedDbObjectStoreSnapshotSchema)
-  },
-  {
-    title: "IndexedDbDatabaseSnapshot",
-    required: ["name", "version", "objectStores"]
-  }
-);
-var storageOriginSnapshotSchema = objectSchema(
-  {
-    origin: stringSchema(),
-    localStorage: arraySchema(storageEntrySchema),
-    indexedDb: arraySchema(indexedDbDatabaseSnapshotSchema)
-  },
-  {
-    title: "StorageOriginSnapshot",
-    required: ["origin", "localStorage"]
-  }
-);
-var sessionStorageSnapshotSchema = objectSchema(
-  {
-    pageRef: pageRefSchema,
-    frameRef: frameRefSchema,
-    origin: stringSchema(),
-    entries: arraySchema(storageEntrySchema)
-  },
-  {
-    title: "SessionStorageSnapshot",
-    required: ["pageRef", "frameRef", "origin", "entries"]
-  }
-);
-var storageSnapshotSchema = objectSchema(
-  {
-    sessionRef: sessionRefSchema,
-    capturedAt: integerSchema({ minimum: 0 }),
-    origins: arraySchema(storageOriginSnapshotSchema),
-    sessionStorage: arraySchema(sessionStorageSnapshotSchema)
+  {
+    recordId: stringSchema({ minLength: 1 }),
+    key: stringSchema({ minLength: 1 }),
+    version: stringSchema({ minLength: 1 }),
+    transport: transportKindSchema
   },
   {
-    title: "StorageSnapshot",
-    required: ["sessionRef", "capturedAt", "origins"]
+    title: "OpensteerInferRequestPlanInput",
+    required: ["recordId", "key", "version"]
   }
 );
 var screenshotFormatSchema = enumSchema(["png", "jpeg", "webp"], {
@@ -2482,12 +2779,7 @@ var cloudSessionStatuses = [
   "closed",
   "failed"
 ];
-var cloudSessionRecordingStatuses = [
-  "idle",
-  "recording",
-  "completed",
-  "failed"
-];
+var cloudSessionRecordingStatuses = ["idle", "recording", "completed", "failed"];
 var cloudSessionSourceTypes = [
   "agent-thread",
   "agent-run",
@@ -4245,181 +4537,6 @@ var opensteerRestEndpoints = opensteerOperationSpecifications.map((spec) => ({
   responseSchema: responseEnvelopeSchema(spec.outputSchema, spec.name)
 }));
 
-// src/diff.ts
-var networkDiffFieldKindSchema = enumSchema(
-  ["added", "removed", "changed", "unchanged"],
-  {
-    title: "NetworkDiffFieldKind"
-  }
-);
-var networkDiffEntropySchema = objectSchema(
-  {
-    left: numberSchema({ minimum: 0 }),
-    right: numberSchema({ minimum: 0 }),
-    likelyEncrypted: { type: "boolean" }
-  },
-  {
-    title: "NetworkDiffEntropy",
-    required: ["likelyEncrypted"]
-  }
-);
-var networkDiffFieldSchema = objectSchema(
-  {
-    path: stringSchema({ minLength: 1 }),
-    kind: networkDiffFieldKindSchema,
-    leftValue: stringSchema(),
-    rightValue: stringSchema(),
-    entropy: networkDiffEntropySchema
-  },
-  {
-    title: "NetworkDiffField",
-    required: ["path", "kind"]
-  }
-);
-var opensteerNetworkDiffInputSchema = objectSchema(
-  {
-    leftRecordId: stringSchema({ minLength: 1 }),
-    rightRecordId: stringSchema({ minLength: 1 }),
-    includeUnchanged: { type: "boolean" },
-    scope: enumSchema(["headers", "body", "all"])
-  },
-  {
-    title: "OpensteerNetworkDiffInput",
-    required: ["leftRecordId", "rightRecordId"]
-  }
-);
-var opensteerNetworkDiffOutputSchema = objectSchema(
-  {
-    summary: objectSchema(
-      {
-        added: numberSchema({ minimum: 0 }),
-        removed: numberSchema({ minimum: 0 }),
-        changed: numberSchema({ minimum: 0 }),
-        unchanged: numberSchema({ minimum: 0 }),
-        likelyEncryptedFields: numberSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerNetworkDiffSummary",
-        required: ["added", "removed", "changed", "unchanged", "likelyEncryptedFields"]
-      }
-    ),
-    requestDiffs: arraySchema(networkDiffFieldSchema),
-    responseDiffs: arraySchema(networkDiffFieldSchema)
-  },
-  {
-    title: "OpensteerNetworkDiffOutput",
-    required: ["summary", "requestDiffs", "responseDiffs"]
-  }
-);
-
-// src/minimize.ts
-var minimizationFieldClassificationSchema = enumSchema(
-  ["required", "optional", "untested"],
-  {
-    title: "MinimizationFieldClassification"
-  }
-);
-var minimizationFieldResultSchema = objectSchema(
-  {
-    name: stringSchema({ minLength: 1 }),
-    location: enumSchema(["header", "cookie", "query", "body-field"]),
-    classification: minimizationFieldClassificationSchema,
-    originalValue: stringSchema()
-  },
-  {
-    title: "MinimizationFieldResult",
-    required: ["name", "location", "classification"]
-  }
-);
-var opensteerNetworkMinimizeSuccessPolicySchema = objectSchema(
-  {
-    statusCodes: arraySchema(integerSchema({ minimum: 100, maximum: 599 }), {
-      minItems: 1,
-      uniqueItems: true
-    }),
-    responseBodyIncludes: arraySchema(stringSchema({ minLength: 1 }), {
-      minItems: 1,
-      uniqueItems: true
-    }),
-    responseStructureMatch: { type: "boolean" }
-  },
-  {
-    title: "OpensteerNetworkMinimizeSuccessPolicy"
-  }
-);
-var opensteerNetworkMinimizeInputSchema = objectSchema(
-  {
-    recordId: stringSchema({ minLength: 1 }),
-    transport: transportKindSchema,
-    successPolicy: opensteerNetworkMinimizeSuccessPolicySchema,
-    maxTrials: integerSchema({ minimum: 1 }),
-    preserve: arraySchema(stringSchema({ minLength: 1 }), {
-      minItems: 1,
-      uniqueItems: true
-    })
-  },
-  {
-    title: "OpensteerNetworkMinimizeInput",
-    required: ["recordId"]
-  }
-);
-var opensteerNetworkMinimizeOutputSchema = objectSchema(
-  {
-    recordId: stringSchema({ minLength: 1 }),
-    totalTrials: integerSchema({ minimum: 0 }),
-    fields: arraySchema(minimizationFieldResultSchema),
-    minimizedPlan: opensteerWriteRequestPlanInputSchema
-  },
-  {
-    title: "OpensteerNetworkMinimizeOutput",
-    required: ["recordId", "totalTrials", "fields"]
-  }
-);
-
-// src/probe.ts
-var transportProbeLevelSchema = enumSchema(
-  ["direct-http", "matched-tls", "context-http", "page-http", "session-http"],
-  {
-    title: "TransportProbeLevel"
-  }
-);
-var opensteerTransportProbeInputSchema = objectSchema(
-  {
-    recordId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerTransportProbeInput",
-    required: ["recordId"]
-  }
-);
-var transportProbeResultSchema = objectSchema(
-  {
-    transport: transportProbeLevelSchema,
-    status: {
-      type: ["integer", "null"],
-      minimum: 100,
-      maximum: 599
-    },
-    success: { type: "boolean" },
-    durationMs: integerSchema({ minimum: 0 }),
-    error: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "TransportProbeResult",
-    required: ["transport", "status", "success", "durationMs"]
-  }
-);
-var opensteerTransportProbeOutputSchema = objectSchema(
-  {
-    results: arraySchema(transportProbeResultSchema),
-    recommendation: transportProbeLevelSchema
-  },
-  {
-    title: "OpensteerTransportProbeOutput",
-    required: ["results", "recommendation"]
-  }
-);
-
 // src/scripts.ts
 var scriptTransformInputSchema = objectSchema(
   {
@@ -6166,14 +6283,14 @@ var targetByElementSchema = objectSchema(
     required: ["kind", "element"]
   }
 );
-var targetByDescriptionSchema = objectSchema(
+var targetByPersistSchema = objectSchema(
   {
-    kind: enumSchema(["description"]),
-    description: stringSchema()
+    kind: enumSchema(["persist"]),
+    name: stringSchema()
   },
   {
-    title: "OpensteerInteractionTargetByDescription",
-    required: ["kind", "description"]
+    title: "OpensteerInteractionTargetByPersist",
+    required: ["kind", "name"]
   }
 );
 var targetBySelectorSchema = objectSchema(
@@ -6187,7 +6304,7 @@ var targetBySelectorSchema = objectSchema(
   }
 );
 var opensteerInteractionTargetInputSchema = oneOfSchema(
-  [targetByElementSchema, targetByDescriptionSchema, targetBySelectorSchema],
+  [targetByElementSchema, targetByPersistSchema, targetBySelectorSchema],
   {
     title: "OpensteerInteractionTargetInput"
   }
@@ -6402,46 +6519,55 @@ var opensteerSemanticOperationNames = [
   "dom.scroll",
   "dom.extract",
   "network.query",
-  "network.tag",
-  "network.clear",
-  "network.minimize",
-  "network.diff",
-  "network.probe",
-  "reverse.discover",
-  "reverse.query",
-  "reverse.package.create",
-  "reverse.package.run",
-  "reverse.export",
-  "reverse.report",
-  "reverse.package.get",
-  "reverse.package.list",
-  "reverse.package.patch",
+  "network.detail",
   "interaction.capture",
   "interaction.get",
   "interaction.diff",
   "interaction.replay",
   "artifact.read",
-  "inspect.cookies",
-  "inspect.storage",
+  "session.cookies",
+  "session.storage",
+  "session.state",
+  "session.fetch",
+  "scripts.capture",
+  "scripts.beautify",
+  "scripts.deobfuscate",
+  "scripts.sandbox",
+  "captcha.solve",
+  "computer.execute",
+  "session.close"
+];
+var opensteerExposedSemanticOperationNames = [
+  "session.open",
+  "page.list",
+  "page.new",
+  "page.activate",
+  "page.close",
+  "page.goto",
+  "page.evaluate",
+  "page.add-init-script",
+  "page.snapshot",
+  "dom.click",
+  "dom.hover",
+  "dom.input",
+  "dom.scroll",
+  "dom.extract",
+  "network.query",
+  "network.detail",
+  "interaction.capture",
+  "interaction.get",
+  "interaction.diff",
+  "interaction.replay",
+  "artifact.read",
+  "session.cookies",
+  "session.storage",
+  "session.state",
+  "session.fetch",
   "scripts.capture",
   "scripts.beautify",
   "scripts.deobfuscate",
   "scripts.sandbox",
   "captcha.solve",
-  "request.raw",
-  "request-plan.infer",
-  "request-plan.write",
-  "request-plan.get",
-  "request-plan.list",
-  "recipe.write",
-  "recipe.get",
-  "recipe.list",
-  "recipe.run",
-  "auth-recipe.write",
-  "auth-recipe.get",
-  "auth-recipe.list",
-  "auth-recipe.run",
-  "request.execute",
   "computer.execute",
   "session.close"
 ];
@@ -6463,40 +6589,23 @@ var opensteerPackageRunnableSemanticOperationNames = /* @__PURE__ */ new Set([
   "dom.scroll",
   "dom.extract",
   "network.query",
-  "network.tag",
-  "network.clear",
-  "network.minimize",
-  "network.diff",
-  "network.probe",
+  "network.detail",
   "interaction.capture",
   "interaction.get",
   "interaction.diff",
   "interaction.replay",
   "artifact.read",
-  "inspect.cookies",
-  "inspect.storage",
+  "session.cookies",
+  "session.storage",
+  "session.state",
+  "session.fetch",
   "scripts.capture",
   "scripts.beautify",
   "scripts.deobfuscate",
   "scripts.sandbox",
   "captcha.solve",
-  "request.raw",
-  "request.execute",
   "computer.execute"
 ]);
-function resolveTransportRequiredCapabilities(transport, fallback) {
-  switch (transport ?? fallback) {
-    case "direct-http":
-      return [];
-    case "matched-tls":
-    case "context-http":
-      return ["inspect.cookies"];
-    case "page-http":
-      return ["pages.manage"];
-    case "session-http":
-      return ["transport.sessionHttp"];
-  }
-}
 var snapshotModeSchema = enumSchema(["action", "extraction"], {
   title: "OpensteerSnapshotMode"
 });
@@ -6598,14 +6707,14 @@ var targetByElementSchema2 = objectSchema(
     required: ["kind", "element"]
   }
 );
-var targetByDescriptionSchema2 = objectSchema(
+var targetByPersistSchema2 = objectSchema(
   {
-    kind: enumSchema(["description"]),
-    description: stringSchema()
+    kind: enumSchema(["persist"]),
+    persist: stringSchema()
   },
   {
-    title: "OpensteerTargetByDescription",
-    required: ["kind", "description"]
+    title: "OpensteerTargetByPersist",
+    required: ["kind", "persist"]
   }
 );
 var targetBySelectorSchema2 = objectSchema(
@@ -6619,7 +6728,7 @@ var targetBySelectorSchema2 = objectSchema(
   }
 );
 var opensteerTargetInputSchema = oneOfSchema(
-  [targetByElementSchema2, targetByDescriptionSchema2, targetBySelectorSchema2],
+  [targetByElementSchema2, targetByPersistSchema2, targetBySelectorSchema2],
   {
     title: "OpensteerTargetInput"
   }
@@ -6633,7 +6742,7 @@ var opensteerResolvedTargetSchema = objectSchema(
     nodeRef: nodeRefSchema,
     tagName: stringSchema(),
     pathHint: stringSchema(),
-    description: stringSchema(),
+    persist: stringSchema(),
     selectorUsed: stringSchema()
   },
   {
@@ -6652,8 +6761,7 @@ var opensteerResolvedTargetSchema = objectSchema(
 var opensteerActionResultSchema = objectSchema(
   {
     target: opensteerResolvedTargetSchema,
-    point: pointSchema,
-    persistedDescription: stringSchema()
+    point: pointSchema
   },
   {
     title: "OpensteerActionResult",
@@ -6910,29 +7018,21 @@ var opensteerPageSnapshotOutputSchema = objectSchema(
     required: ["url", "title", "mode", "html", "counters"]
   }
 );
-var opensteerInspectCookiesInputSchema = objectSchema(
+var opensteerNetworkDetailInputSchema = objectSchema(
   {
-    urls: arraySchema(stringSchema({ minLength: 1 }))
+    recordId: stringSchema({ minLength: 1 })
   },
   {
-    title: "OpensteerInspectCookiesInput"
+    title: "OpensteerNetworkDetailInput",
+    required: ["recordId"]
   }
 );
-var opensteerInspectCookiesOutputSchema = arraySchema(cookieRecordSchema, {
-  title: "OpensteerInspectCookiesOutput"
-});
-var opensteerInspectStorageInputSchema = objectSchema(
-  {
-    includeSessionStorage: { type: "boolean" },
-    includeIndexedDb: { type: "boolean" }
-  },
+var opensteerComputerMouseButtonSchema = enumSchema(
+  ["left", "middle", "right"],
   {
-    title: "OpensteerInspectStorageInput"
+    title: "OpensteerComputerMouseButton"
   }
 );
-var opensteerComputerMouseButtonSchema = enumSchema(["left", "middle", "right"], {
-  title: "OpensteerComputerMouseButton"
-});
 var opensteerComputerKeyModifierSchema = enumSchema(
   ["Shift", "Control", "Alt", "Meta"],
   {
@@ -6947,7 +7047,7 @@ var opensteerDomClickInputSchema = objectSchema(
     modifiers: arraySchema(opensteerComputerKeyModifierSchema, {
       uniqueItems: true
     }),
-    persistAsDescription: stringSchema(),
+    persist: stringSchema(),
     captureNetwork: stringSchema({ minLength: 1 })
   },
   {
@@ -6958,7 +7058,7 @@ var opensteerDomClickInputSchema = objectSchema(
 var opensteerDomHoverInputSchema = objectSchema(
   {
     target: opensteerTargetInputSchema,
-    persistAsDescription: stringSchema(),
+    persist: stringSchema(),
     captureNetwork: stringSchema({ minLength: 1 })
   },
   {
@@ -6971,7 +7071,7 @@ var opensteerDomInputInputSchema = objectSchema(
     target: opensteerTargetInputSchema,
     text: stringSchema(),
     pressEnter: { type: "boolean" },
-    persistAsDescription: stringSchema(),
+    persist: stringSchema(),
     captureNetwork: stringSchema({ minLength: 1 })
   },
   {
@@ -6984,7 +7084,7 @@ var opensteerDomScrollInputSchema = objectSchema(
     target: opensteerTargetInputSchema,
     direction: enumSchema(["up", "down", "left", "right"]),
     amount: integerSchema({ minimum: 1 }),
-    persistAsDescription: stringSchema(),
+    persist: stringSchema(),
     captureNetwork: stringSchema({ minLength: 1 })
   },
   {
@@ -6999,16 +7099,18 @@ var opensteerExtractSchemaSchema = objectSchema(
     additionalProperties: true
   }
 );
-var opensteerDomExtractInputSchema = objectSchema(
-  {
-    description: stringSchema(),
-    schema: opensteerExtractSchemaSchema
-  },
-  {
-    title: "OpensteerDomExtractInput",
-    required: ["description"]
-  }
-);
+var opensteerDomExtractInputSchema = defineSchema({
+  ...objectSchema(
+    {
+      persist: stringSchema(),
+      schema: opensteerExtractSchemaSchema
+    },
+    {
+      title: "OpensteerDomExtractInput"
+    }
+  ),
+  anyOf: [defineSchema({ required: ["persist"] }), defineSchema({ required: ["schema"] })]
+});
 var jsonValueSchema3 = recordSchema({}, { title: "JsonValueRecord" });
 var opensteerDomExtractOutputSchema = objectSchema(
   {
@@ -7371,116 +7473,24 @@ var opensteerSemanticOperationSpecificationsBase = [
   }),
   defineSemanticOperationSpec({
     name: "dom.extract",
-    description: "Run structured DOM extraction with persisted Opensteer extraction descriptors.",
+    description: "Run structured DOM extraction and optionally persist the extraction descriptor for replay.",
     inputSchema: opensteerDomExtractInputSchema,
     outputSchema: opensteerDomExtractOutputSchema,
     requiredCapabilities: ["inspect.domSnapshot", "inspect.text", "inspect.attributes"]
   }),
   defineSemanticOperationSpec({
     name: "network.query",
-    description: "Query persisted network records for reverse engineering workflows.",
+    description: "Query captured network traffic with chronological summaries optimized for agent inspection.",
     inputSchema: opensteerNetworkQueryInputSchema,
     outputSchema: opensteerNetworkQueryOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "network.tag",
-    description: "Apply a tag to persisted network records matching the provided filters.",
-    inputSchema: opensteerNetworkTagInputSchema,
-    outputSchema: opensteerNetworkTagOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "network.clear",
-    description: "Clear saved network records globally or for a specific tag.",
-    inputSchema: opensteerNetworkClearInputSchema,
-    outputSchema: opensteerNetworkClearOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "network.minimize",
-    description: "Minimize a saved captured request by identifying the smallest viable header, cookie, query, and body-field set.",
-    inputSchema: opensteerNetworkMinimizeInputSchema,
-    outputSchema: opensteerNetworkMinimizeOutputSchema,
-    requiredCapabilities: [],
-    resolveRequiredCapabilities: (input) => resolveTransportRequiredCapabilities(input.transport, "session-http")
-  }),
-  defineSemanticOperationSpec({
-    name: "network.diff",
-    description: "Compare two captured requests and responses field-by-field with entropy analysis for likely encrypted values.",
-    inputSchema: opensteerNetworkDiffInputSchema,
-    outputSchema: opensteerNetworkDiffOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "network.probe",
-    description: "Probe a captured request across transport layers and recommend the lightest working execution path.",
-    inputSchema: opensteerTransportProbeInputSchema,
-    outputSchema: opensteerTransportProbeOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "reverse.discover",
-    description: "Capture and index a bounded reverse-engineering observation window, then return the case handle, summary, report id, and query metadata only.",
-    inputSchema: opensteerReverseDiscoverInputSchema,
-    outputSchema: opensteerReverseDiscoverOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "reverse.query",
-    description: "Query a cached reverse case with deterministic filters and explicit sort keys or preset shortcuts over records, clusters, or candidates.",
-    inputSchema: opensteerReverseQueryInputSchema,
-    outputSchema: opensteerReverseQueryOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "reverse.package.create",
-    description: "Create an explicit reverse package draft from a chosen observed record or advisory candidate, with an optional advisory template.",
-    inputSchema: opensteerReversePackageCreateInputSchema,
-    outputSchema: opensteerReversePackageCreateOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "reverse.package.run",
-    description: "Run a reverse package draft through its operation, await-record, and assertion steps, returning executed bindings and first failure details.",
-    inputSchema: opensteerReversePackageRunInputSchema,
-    outputSchema: opensteerReversePackageRunOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "reverse.export",
-    description: "Export or clone a reverse-engineering package, including a request plan when the package is portable.",
-    inputSchema: opensteerReverseExportInputSchema,
-    outputSchema: opensteerReverseExportOutputSchema,
-    requiredCapabilities: []
+    requiredCapabilities: ["inspect.network"]
   }),
   defineSemanticOperationSpec({
-    name: "reverse.report",
-    description: "Read an evidence-centered discovery report or a draft-centered package report, including linked evidence, replay attempts, and advisory suggestions.",
-    inputSchema: opensteerReverseReportInputSchema,
-    outputSchema: opensteerReverseReportOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "reverse.package.get",
-    description: "Read a standalone reverse-engineering package so an agent can inspect its workflow, resolvers, requirements, and linked evidence.",
-    inputSchema: opensteerReversePackageGetInputSchema,
-    outputSchema: opensteerReversePackageGetOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "reverse.package.list",
-    description: "List reverse-engineering packages by case, key, kind, or readiness.",
-    inputSchema: opensteerReversePackageListInputSchema,
-    outputSchema: opensteerReversePackageListOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "reverse.package.patch",
-    description: "Write a new immutable reverse-engineering package revision by patching editable workflow, resolver, validator, and evidence sections.",
-    inputSchema: opensteerReversePackagePatchInputSchema,
-    outputSchema: opensteerReversePackagePatchOutputSchema,
-    requiredCapabilities: []
+    name: "network.detail",
+    description: "Inspect one captured network record with parsed headers, cookies, redirects, and truncated bodies.",
+    inputSchema: opensteerNetworkDetailInputSchema,
+    outputSchema: opensteerNetworkDetailOutputSchema,
+    requiredCapabilities: ["inspect.network", "inspect.networkBodies"]
   }),
   defineSemanticOperationSpec({
     name: "interaction.capture",
@@ -7553,127 +7563,49 @@ var opensteerSemanticOperationSpecificationsBase = [
     requiredCapabilities: ["pages.manage"]
   }),
   defineSemanticOperationSpec({
-    name: "inspect.cookies",
-    description: "Read cookies from the current browser session.",
-    inputSchema: opensteerInspectCookiesInputSchema,
-    outputSchema: opensteerInspectCookiesOutputSchema,
+    name: "session.cookies",
+    description: "Read browser cookies for the active page domain or an explicitly selected domain.",
+    inputSchema: opensteerCookieQueryInputSchema,
+    outputSchema: opensteerCookieQueryOutputSchema,
     requiredCapabilities: ["inspect.cookies"]
   }),
   defineSemanticOperationSpec({
-    name: "inspect.storage",
-    description: "Read browser storage state from the current browser session.",
-    inputSchema: opensteerInspectStorageInputSchema,
-    outputSchema: storageSnapshotSchema,
-    requiredCapabilities: ["inspect.localStorage"],
-    resolveRequiredCapabilities: (input) => {
-      const capabilities = ["inspect.localStorage"];
-      if (input.includeSessionStorage ?? false) {
-        capabilities.push("inspect.sessionStorage");
-      }
-      if (input.includeIndexedDb ?? false) {
-        capabilities.push("inspect.indexedDb");
-      }
-      return capabilities;
-    }
-  }),
-  defineSemanticOperationSpec({
-    name: "request.raw",
-    description: "Execute a raw HTTP request through either the current browser session or a direct HTTP transport.",
-    inputSchema: opensteerRawRequestInputSchema,
-    outputSchema: opensteerRawRequestOutputSchema,
-    requiredCapabilities: [],
-    resolveRequiredCapabilities: (input) => resolveTransportRequiredCapabilities(input.transport, "context-http")
-  }),
-  defineSemanticOperationSpec({
-    name: "request-plan.infer",
-    description: "Infer and persist a request plan from a selected network record.",
-    inputSchema: opensteerInferRequestPlanInputSchema,
-    outputSchema: opensteerRequestPlanRecordSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "request-plan.write",
-    description: "Validate and persist a reusable request plan in the local registry.",
-    inputSchema: opensteerWriteRequestPlanInputSchema,
-    outputSchema: opensteerRequestPlanRecordSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "request-plan.get",
-    description: "Resolve a request plan by key and optional version.",
-    inputSchema: opensteerGetRequestPlanInputSchema,
-    outputSchema: opensteerRequestPlanRecordSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "request-plan.list",
-    description: "List request plans from the local registry.",
-    inputSchema: opensteerListRequestPlansInputSchema,
-    outputSchema: opensteerListRequestPlansOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "recipe.write",
-    description: "Validate and persist a reusable recipe in the local registry.",
-    inputSchema: opensteerWriteAuthRecipeInputSchema,
-    outputSchema: opensteerAuthRecipeRecordSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "recipe.get",
-    description: "Resolve a recipe by key and optional version.",
-    inputSchema: opensteerGetAuthRecipeInputSchema,
-    outputSchema: opensteerAuthRecipeRecordSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "recipe.list",
-    description: "List recipes from the local registry.",
-    inputSchema: opensteerListAuthRecipesInputSchema,
-    outputSchema: opensteerListAuthRecipesOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "recipe.run",
-    description: "Run a stored recipe deterministically against the current runtime.",
-    inputSchema: opensteerRunAuthRecipeInputSchema,
-    outputSchema: opensteerRunAuthRecipeOutputSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "auth-recipe.write",
-    description: "Validate and persist a reusable auth recovery recipe in the local registry.",
-    inputSchema: opensteerWriteAuthRecipeInputSchema,
-    outputSchema: opensteerAuthRecipeRecordSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "auth-recipe.get",
-    description: "Resolve an auth recipe by key and optional version.",
-    inputSchema: opensteerGetAuthRecipeInputSchema,
-    outputSchema: opensteerAuthRecipeRecordSchema,
-    requiredCapabilities: []
-  }),
-  defineSemanticOperationSpec({
-    name: "auth-recipe.list",
-    description: "List auth recovery recipes from the local registry.",
-    inputSchema: opensteerListAuthRecipesInputSchema,
-    outputSchema: opensteerListAuthRecipesOutputSchema,
-    requiredCapabilities: []
+    name: "session.storage",
+    description: "Read localStorage and sessionStorage grouped by domain for the active browser session.",
+    inputSchema: opensteerStorageQueryInputSchema,
+    outputSchema: opensteerStorageQueryOutputSchema,
+    requiredCapabilities: ["inspect.localStorage", "inspect.sessionStorage"]
   }),
   defineSemanticOperationSpec({
-    name: "auth-recipe.run",
-    description: "Run a stored auth recovery recipe deterministically against the current runtime.",
-    inputSchema: opensteerRunAuthRecipeInputSchema,
-    outputSchema: opensteerRunAuthRecipeOutputSchema,
-    requiredCapabilities: []
+    name: "session.state",
+    description: "Read browser cookies, storage, hidden fields, and selected page globals grouped by domain.",
+    inputSchema: opensteerStateQueryInputSchema,
+    outputSchema: opensteerStateQueryOutputSchema,
+    requiredCapabilities: [
+      "inspect.cookies",
+      "inspect.localStorage",
+      "inspect.sessionStorage",
+      "pages.manage"
+    ]
   }),
   defineSemanticOperationSpec({
-    name: "request.execute",
-    description: "Execute a request plan through its configured transport and deterministic auth recovery policy.",
-    inputSchema: opensteerRequestExecuteInputSchema,
-    outputSchema: opensteerRequestExecuteOutputSchema,
-    requiredCapabilities: []
+    name: "session.fetch",
+    description: "Execute a session-aware HTTP request with browser cookies and automatic transport selection.",
+    inputSchema: opensteerSessionFetchInputSchema,
+    outputSchema: exports.opensteerSessionFetchOutputSchema,
+    requiredCapabilities: [],
+    resolveRequiredCapabilities: (input) => {
+      switch (input.transport ?? "auto") {
+        case "direct":
+          return [];
+        case "matched-tls":
+          return ["inspect.cookies"];
+        case "page":
+          return ["pages.manage"];
+        case "auto":
+          return ["inspect.cookies", "pages.manage"];
+      }
+    }
   }),
   defineSemanticOperationSpec({
     name: "computer.execute",
@@ -7711,12 +7643,18 @@ var opensteerSemanticOperationSpecificationsBase = [
     requiredCapabilities: ["sessions.manage"]
   })
 ];
-var opensteerSemanticOperationSpecifications = opensteerSemanticOperationSpecificationsBase.map((spec) => ({
+var exposedSemanticOperationNameSet = new Set(
+  opensteerExposedSemanticOperationNames
+);
+var opensteerSemanticOperationSpecificationsInternal = opensteerSemanticOperationSpecificationsBase.map((spec) => ({
   ...spec,
   packageRunnable: opensteerPackageRunnableSemanticOperationNames.has(spec.name)
 }));
+var opensteerSemanticOperationSpecifications = opensteerSemanticOperationSpecificationsInternal.filter(
+  (spec) => exposedSemanticOperationNameSet.has(spec.name)
+);
 var opensteerSemanticOperationSpecificationMap = Object.fromEntries(
-  opensteerSemanticOperationSpecifications.map((spec) => [spec.name, spec])
+  opensteerSemanticOperationSpecificationsInternal.map((spec) => [spec.name, spec])
 );
 var semanticRestBasePath = `${OPENSTEER_PROTOCOL_REST_BASE_PATH}/semantic`;
 var opensteerSemanticRestEndpoints = opensteerSemanticOperationSpecifications.map((spec) => ({
@@ -7733,13 +7671,12 @@ var readOnlyOperations = /* @__PURE__ */ new Set([
   "page.snapshot",
   "dom.extract",
   "network.query",
-  "request-plan.get",
-  "request-plan.list"
-]);
-var destructiveOperations = /* @__PURE__ */ new Set([
-  "network.clear",
-  "session.close"
+  "network.detail",
+  "session.cookies",
+  "session.storage",
+  "session.state"
 ]);
+var destructiveOperations = /* @__PURE__ */ new Set(["session.close"]);
 function toolNameFromOperation(operation) {
   return `opensteer_${operation.replaceAll(".", "_").replaceAll("-", "_")}`;
 }
@@ -7983,12 +7920,7 @@ exports.isOpensteerRef = isOpensteerRef;
 exports.isSupportedProtocolVersion = isSupportedProtocolVersion;
 exports.layoutViewportSchema = layoutViewportSchema;
 exports.literalSchema = literalSchema;
-exports.minimizationFieldClassificationSchema = minimizationFieldClassificationSchema;
-exports.minimizationFieldResultSchema = minimizationFieldResultSchema;
 exports.networkCaptureStateSchema = networkCaptureStateSchema;
-exports.networkDiffEntropySchema = networkDiffEntropySchema;
-exports.networkDiffFieldKindSchema = networkDiffFieldKindSchema;
-exports.networkDiffFieldSchema = networkDiffFieldSchema;
 exports.networkInitiatorSchema = networkInitiatorSchema;
 exports.networkInitiatorTypeSchema = networkInitiatorTypeSchema;
 exports.networkQueryRecordSchema = networkQueryRecordSchema;
@@ -8037,6 +7969,8 @@ exports.opensteerCapabilitySetSchema = opensteerCapabilitySetSchema;
 exports.opensteerCaptchaSolveInputSchema = opensteerCaptchaSolveInputSchema;
 exports.opensteerCaptchaSolveOutputSchema = opensteerCaptchaSolveOutputSchema;
 exports.opensteerComputerAnnotationNames = opensteerComputerAnnotationNames;
+exports.opensteerCookieQueryInputSchema = opensteerCookieQueryInputSchema;
+exports.opensteerCookieQueryOutputSchema = opensteerCookieQueryOutputSchema;
 exports.opensteerErrorCodeSchema = opensteerErrorCodeSchema;
 exports.opensteerErrorCodes = opensteerErrorCodes;
 exports.opensteerErrorEnvelopeSchema = opensteerErrorEnvelopeSchema;
@@ -8044,6 +7978,7 @@ exports.opensteerErrorSchema = opensteerErrorSchema;
 exports.opensteerEventSchema = opensteerEventSchema;
 exports.opensteerExecutableResolverKindSchema = opensteerExecutableResolverKindSchema;
 exports.opensteerExecutableResolverSchema = opensteerExecutableResolverSchema;
+exports.opensteerExposedSemanticOperationNames = opensteerExposedSemanticOperationNames;
 exports.opensteerGetAuthRecipeInputSchema = opensteerGetAuthRecipeInputSchema;
 exports.opensteerGetRecipeInputSchema = opensteerGetRecipeInputSchema;
 exports.opensteerGetRequestPlanInputSchema = opensteerGetRequestPlanInputSchema;
@@ -8068,13 +8003,11 @@ exports.opensteerListRequestPlansOutputSchema = opensteerListRequestPlansOutputS
 exports.opensteerMcpTools = opensteerMcpTools;
 exports.opensteerNetworkClearInputSchema = opensteerNetworkClearInputSchema;
 exports.opensteerNetworkClearOutputSchema = opensteerNetworkClearOutputSchema;
-exports.opensteerNetworkDiffInputSchema = opensteerNetworkDiffInputSchema;
-exports.opensteerNetworkDiffOutputSchema = opensteerNetworkDiffOutputSchema;
-exports.opensteerNetworkMinimizeInputSchema = opensteerNetworkMinimizeInputSchema;
-exports.opensteerNetworkMinimizeOutputSchema = opensteerNetworkMinimizeOutputSchema;
-exports.opensteerNetworkMinimizeSuccessPolicySchema = opensteerNetworkMinimizeSuccessPolicySchema;
+exports.opensteerNetworkDetailOutputSchema = opensteerNetworkDetailOutputSchema;
 exports.opensteerNetworkQueryInputSchema = opensteerNetworkQueryInputSchema;
 exports.opensteerNetworkQueryOutputSchema = opensteerNetworkQueryOutputSchema;
+exports.opensteerNetworkReplayInputSchema = opensteerNetworkReplayInputSchema;
+exports.opensteerNetworkSummaryRecordSchema = opensteerNetworkSummaryRecordSchema;
 exports.opensteerNetworkTagInputSchema = opensteerNetworkTagInputSchema;
 exports.opensteerNetworkTagOutputSchema = opensteerNetworkTagOutputSchema;
 exports.opensteerObservationClusterRelationshipKindSchema = opensteerObservationClusterRelationshipKindSchema;
@@ -8199,12 +8132,15 @@ exports.opensteerSemanticOperationNames = opensteerSemanticOperationNames;
 exports.opensteerSemanticOperationSpecificationMap = opensteerSemanticOperationSpecificationMap;
 exports.opensteerSemanticOperationSpecifications = opensteerSemanticOperationSpecifications;
 exports.opensteerSemanticRestEndpoints = opensteerSemanticRestEndpoints;
+exports.opensteerSessionFetchInputSchema = opensteerSessionFetchInputSchema;
 exports.opensteerSessionGrantKinds = opensteerSessionGrantKinds;
 exports.opensteerStateDeltaSchema = opensteerStateDeltaSchema;
+exports.opensteerStateQueryInputSchema = opensteerStateQueryInputSchema;
+exports.opensteerStateQueryOutputSchema = opensteerStateQueryOutputSchema;
 exports.opensteerStateSnapshotSchema = opensteerStateSnapshotSchema;
 exports.opensteerStateSourceKindSchema = opensteerStateSourceKindSchema;
-exports.opensteerTransportProbeInputSchema = opensteerTransportProbeInputSchema;
-exports.opensteerTransportProbeOutputSchema = opensteerTransportProbeOutputSchema;
+exports.opensteerStorageQueryInputSchema = opensteerStorageQueryInputSchema;
+exports.opensteerStorageQueryOutputSchema = opensteerStorageQueryOutputSchema;
 exports.opensteerValidationRuleKindSchema = opensteerValidationRuleKindSchema;
 exports.opensteerValidationRuleSchema = opensteerValidationRuleSchema;
 exports.opensteerValueReferenceKindSchema = opensteerValueReferenceKindSchema;
@@ -8250,8 +8186,6 @@ exports.traceBundleSchema = traceBundleSchema;
 exports.traceContextSchema = traceContextSchema;
 exports.traceRecordSchema = traceRecordSchema;
 exports.transportKindSchema = transportKindSchema;
-exports.transportProbeLevelSchema = transportProbeLevelSchema;
-exports.transportProbeResultSchema = transportProbeResultSchema;
 exports.unsupportedCapabilityError = unsupportedCapabilityError;
 exports.unsupportedVersionError = unsupportedVersionError;
 exports.validateJsonSchema = validateJsonSchema;