opensteer 0.9.1 → 0.9.2

package/dist/cli/bin.cjs

@@ -3109,62 +3109,6 @@ var init_network2 = __esm({
   }
 });
 
-// ../protocol/src/captcha.ts
-var captchaTypeSchema, captchaProviderSchema, captchaDetectionResultSchema, opensteerCaptchaSolveInputSchema, opensteerCaptchaSolveOutputSchema;
-var init_captcha = __esm({
-  "../protocol/src/captcha.ts"() {
-    init_json2();
-    init_identity2();
-    captchaTypeSchema = enumSchema(
-      ["recaptcha-v2", "hcaptcha", "turnstile"],
-      {
-        title: "CaptchaType"
-      }
-    );
-    captchaProviderSchema = enumSchema(["2captcha", "capsolver"], {
-      title: "CaptchaProvider"
-    });
-    captchaDetectionResultSchema = objectSchema(
-      {
-        type: captchaTypeSchema,
-        siteKey: stringSchema({ minLength: 1 }),
-        pageUrl: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "CaptchaDetectionResult",
-        required: ["type", "siteKey", "pageUrl"]
-      }
-    );
-    opensteerCaptchaSolveInputSchema = objectSchema(
-      {
-        provider: captchaProviderSchema,
-        apiKey: stringSchema({ minLength: 1 }),
-        pageRef: pageRefSchema,
-        timeoutMs: integerSchema({ minimum: 1 }),
-        type: captchaTypeSchema,
-        siteKey: stringSchema({ minLength: 1 }),
-        pageUrl: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerCaptchaSolveInput",
-        required: ["provider", "apiKey"]
-      }
-    );
-    opensteerCaptchaSolveOutputSchema = objectSchema(
-      {
-        captcha: captchaDetectionResultSchema,
-        token: stringSchema({ minLength: 1 }),
-        injected: { type: "boolean" },
-        provider: captchaProviderSchema
-      },
-      {
-        title: "OpensteerCaptchaSolveOutput",
-        required: ["captcha", "token", "injected", "provider"]
-      }
-    );
-  }
-});
-
 // ../protocol/src/storage.ts
 var jsonUnknownSchema, cookieSameSiteSchema, cookiePrioritySchema, cookieRecordSchema, storageEntrySchema, indexedDbRecordSchema, indexedDbIndexSnapshotSchema, indexedDbObjectStoreSnapshotSchema, indexedDbDatabaseSnapshotSchema, storageOriginSnapshotSchema, sessionStorageSnapshotSchema, storageSnapshotSchema;
 var init_storage2 = __esm({
@@ -3312,11 +3256,10 @@ var init_storage2 = __esm({
 });
 
 // ../protocol/src/requests.ts
-var opensteerRequestScalarSchema, opensteerRequestScalarMapSchema, opensteerRequestEntrySchema, opensteerRequestPlanParameterLocationSchema, opensteerRequestPlanParameterSchema, opensteerRequestPlanTransportSchema, opensteerRequestPlanEndpointSchema, opensteerRequestPlanBodySchema, transportKindSchema, opensteerRequestPlanStatusSchema, opensteerRequestPlanResponseExpectationSchema, opensteerRecipeRefSchema, opensteerRequestFailurePolicyHeaderMatchSchema, opensteerRequestFailurePolicySchema, opensteerRequestRetryBackoffPolicySchema, opensteerRequestRetryPolicySchema, opensteerRecipeCachePolicySchema, opensteerRequestPlanRecipeBindingSchema, opensteerRequestPlanRecoverBindingSchema, opensteerRequestPlanRecipesSchema, opensteerRequestPlanAuthSchema, opensteerRequestPlanPayloadSchema, opensteerRegistryProvenanceSchema, opensteerRequestPlanFreshnessSchema, opensteerRequestPlanRecordSchema, jsonValueSchema, opensteerRequestBodyInputSchema, opensteerRecipeRetryOverridesSchema, opensteerRecipeStepResponseCaptureSchema, opensteerRecipeRequestStepInputSchema, opensteerRecipeHookRefSchema, opensteerRecipeStepSchema, opensteerRecipePayloadSchema, opensteerRecipeRecordSchema, opensteerNetworkQueryInputSchema, opensteerGraphqlSummarySchema, opensteerNetworkBodySummarySchema, opensteerNetworkSummaryRecordSchema, opensteerNetworkQueryOutputSchema, opensteerNetworkDetailInputSchema, opensteerParsedCookieSchema, opensteerStructuredBodyPreviewSchema, opensteerNetworkRedirectHopSchema, opensteerReplayAttemptSchema, opensteerNetworkDetailOutputSchema, opensteerSessionFetchTransportSchema, opensteerSessionFetchInputSchema, opensteerSessionFetchOutputSchema, opensteerCookieQueryInputSchema, opensteerCookieQueryOutputSchema, opensteerStorageDomainSnapshotSchema, opensteerStorageQueryInputSchema, opensteerStorageQueryOutputSchema, opensteerHiddenFieldSchema, opensteerStateDomainSnapshotSchema, opensteerStateQueryInputSchema, opensteerStateQueryOutputSchema, opensteerRequestTransportResultSchema, opensteerRequestResponseResultSchema;
+var opensteerRequestScalarSchema, opensteerRequestScalarMapSchema, opensteerRequestEntrySchema, opensteerRequestPlanParameterLocationSchema, opensteerRequestPlanParameterSchema, opensteerRequestPlanTransportSchema, opensteerRequestPlanEndpointSchema, opensteerRequestPlanBodySchema, transportKindSchema, opensteerRequestPlanStatusSchema, opensteerRequestPlanResponseExpectationSchema, opensteerRequestFailurePolicyHeaderMatchSchema, opensteerRequestFailurePolicySchema, opensteerRequestRetryBackoffPolicySchema, opensteerRequestRetryPolicySchema, opensteerRequestPlanAuthSchema, opensteerRequestPlanPayloadSchema, opensteerRegistryProvenanceSchema, opensteerRequestPlanFreshnessSchema, opensteerRequestPlanRecordSchema, jsonValueSchema, opensteerRequestBodyInputSchema, opensteerNetworkQueryInputSchema, opensteerGraphqlSummarySchema, opensteerNetworkBodySummarySchema, opensteerNetworkSummaryRecordSchema, opensteerNetworkQueryOutputSchema, opensteerNetworkDetailInputSchema, opensteerParsedCookieSchema, opensteerStructuredBodyPreviewSchema, opensteerNetworkRedirectHopSchema, opensteerReplayAttemptSchema, opensteerNetworkDetailOutputSchema, opensteerSessionFetchTransportSchema, opensteerSessionFetchInputSchema, opensteerSessionFetchOutputSchema, opensteerCookieQueryInputSchema, opensteerCookieQueryOutputSchema, opensteerStorageDomainSnapshotSchema, opensteerStorageQueryInputSchema, opensteerStorageQueryOutputSchema, opensteerHiddenFieldSchema, opensteerStateDomainSnapshotSchema, opensteerStateQueryInputSchema, opensteerStateQueryOutputSchema, opensteerRequestTransportResultSchema, opensteerRequestResponseResultSchema;
 var init_requests = __esm({
   "../protocol/src/requests.ts"() {
     init_network2();
-    init_captcha();
     init_identity2();
     init_storage2();
     init_json2();
@@ -3432,16 +3375,6 @@ var init_requests = __esm({
         required: ["status"]
       }
     );
-    opensteerRecipeRefSchema = objectSchema(
-      {
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeRef",
-        required: ["key"]
-      }
-    );
     opensteerRequestFailurePolicyHeaderMatchSchema = objectSchema(
       {
         name: stringSchema({ minLength: 1 }),
@@ -3497,46 +3430,9 @@ var init_requests = __esm({
         required: ["maxRetries"]
       }
     );
-    opensteerRecipeCachePolicySchema = enumSchema(
-      ["none", "untilFailure"],
-      {
-        title: "OpensteerRecipeCachePolicy"
-      }
-    );
-    opensteerRequestPlanRecipeBindingSchema = objectSchema(
-      {
-        recipe: opensteerRecipeRefSchema,
-        cachePolicy: opensteerRecipeCachePolicySchema
-      },
-      {
-        title: "OpensteerRequestPlanRecipeBinding",
-        required: ["recipe"]
-      }
-    );
-    opensteerRequestPlanRecoverBindingSchema = objectSchema(
-      {
-        recipe: opensteerRecipeRefSchema,
-        cachePolicy: opensteerRecipeCachePolicySchema,
-        failurePolicy: opensteerRequestFailurePolicySchema
-      },
-      {
-        title: "OpensteerRequestPlanRecoverBinding",
-        required: ["recipe", "failurePolicy"]
-      }
-    );
-    opensteerRequestPlanRecipesSchema = objectSchema(
-      {
-        prepare: opensteerRequestPlanRecipeBindingSchema,
-        recover: opensteerRequestPlanRecoverBindingSchema
-      },
-      {
-        title: "OpensteerRequestPlanRecipes"
-      }
-    );
     opensteerRequestPlanAuthSchema = objectSchema(
       {
         strategy: enumSchema(["session-cookie", "bearer-token", "api-key", "custom"]),
-        recipe: opensteerRecipeRefSchema,
         failurePolicy: opensteerRequestFailurePolicySchema,
         description: stringSchema({ minLength: 1 })
       },
@@ -3552,7 +3448,6 @@ var init_requests = __esm({
         parameters: arraySchema(opensteerRequestPlanParameterSchema),
         body: opensteerRequestPlanBodySchema,
         response: opensteerRequestPlanResponseExpectationSchema,
-        recipes: opensteerRequestPlanRecipesSchema,
         retryPolicy: opensteerRequestRetryPolicySchema,
         auth: opensteerRequestPlanAuthSchema
       },
@@ -3643,629 +3538,318 @@ var init_requests = __esm({
         title: "OpensteerRequestBodyInput"
       }
     );
-    opensteerRecipeRetryOverridesSchema = objectSchema(
+    opensteerNetworkQueryInputSchema = objectSchema(
       {
-        params: recordSchema(stringSchema(), {
-          title: "OpensteerRecipeParams"
-        }),
-        headers: recordSchema(stringSchema(), {
-          title: "OpensteerRecipeHeaders"
-        }),
-        query: recordSchema(stringSchema(), {
-          title: "OpensteerRecipeQuery"
-        }),
-        body: recordSchema(stringSchema(), {
-          title: "OpensteerRecipeBodyVariables"
-        })
+        pageRef: pageRefSchema,
+        recordId: stringSchema({ minLength: 1 }),
+        requestId: stringSchema({ minLength: 1 }),
+        capture: stringSchema({ minLength: 1 }),
+        tag: stringSchema({ minLength: 1 }),
+        url: stringSchema({ minLength: 1 }),
+        hostname: stringSchema({ minLength: 1 }),
+        path: stringSchema({ minLength: 1 }),
+        method: stringSchema({ minLength: 1 }),
+        status: oneOfSchema([
+          integerSchema({ minimum: 100, maximum: 599 }),
+          stringSchema({ minLength: 1 })
+        ]),
+        resourceType: networkResourceTypeSchema,
+        includeBodies: { type: "boolean" },
+        json: { type: "boolean" },
+        before: stringSchema({ minLength: 1 }),
+        after: stringSchema({ minLength: 1 }),
+        limit: integerSchema({ minimum: 1, maximum: 1e3 })
       },
       {
-        title: "OpensteerRecipeRetryOverrides"
+        title: "OpensteerNetworkQueryInput"
       }
     );
-    opensteerRecipeStepResponseCaptureSchema = objectSchema(
+    opensteerGraphqlSummarySchema = objectSchema(
       {
-        header: objectSchema(
-          {
-            name: stringSchema({ minLength: 1 }),
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerAuthRecipeHeaderCapture",
-            required: ["name", "saveAs"]
-          }
-        ),
-        bodyJsonPointer: objectSchema(
-          {
-            pointer: stringSchema({ minLength: 1 }),
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerAuthRecipeBodyJsonPointerCapture",
-            required: ["pointer", "saveAs"]
-          }
-        ),
-        bodyText: objectSchema(
+        operationType: enumSchema(["query", "mutation", "subscription", "unknown"]),
+        operationName: stringSchema({ minLength: 1 }),
+        persisted: { type: "boolean" }
+      },
+      {
+        title: "OpensteerGraphqlSummary"
+      }
+    );
+    opensteerNetworkBodySummarySchema = objectSchema(
+      {
+        bytes: integerSchema({ minimum: 0 }),
+        contentType: stringSchema({ minLength: 1 }),
+        streaming: { type: "boolean" }
+      },
+      {
+        title: "OpensteerNetworkBodySummary"
+      }
+    );
+    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(
           {
-            saveAs: stringSchema({ minLength: 1 })
+            subprotocol: stringSchema({ minLength: 1 })
           },
           {
-            title: "OpensteerAuthRecipeBodyTextCapture",
-            required: ["saveAs"]
+            title: "OpensteerWebsocketSummary"
           }
         )
       },
       {
-        title: "OpensteerRecipeStepResponseCapture"
+        title: "OpensteerNetworkSummaryRecord",
+        required: ["recordId", "kind", "method", "resourceType", "url"]
       }
     );
-    opensteerRecipeRequestStepInputSchema = objectSchema(
+    opensteerNetworkQueryOutputSchema = objectSchema(
+      {
+        records: arraySchema(opensteerNetworkSummaryRecordSchema)
+      },
+      {
+        title: "OpensteerNetworkQueryOutput",
+        required: ["records"]
+      }
+    );
+    opensteerNetworkDetailInputSchema = objectSchema(
+      {
+        recordId: stringSchema({ minLength: 1 }),
+        probe: { type: "boolean" }
+      },
+      {
+        title: "OpensteerNetworkDetailInput",
+        required: ["recordId"]
+      }
+    );
+    opensteerParsedCookieSchema = objectSchema(
+      {
+        name: stringSchema({ minLength: 1 }),
+        value: stringSchema()
+      },
+      {
+        title: "OpensteerParsedCookie",
+        required: ["name", "value"]
+      }
+    );
+    opensteerStructuredBodyPreviewSchema = objectSchema(
+      {
+        contentType: stringSchema({ minLength: 1 }),
+        bytes: integerSchema({ minimum: 0 }),
+        truncated: { type: "boolean" },
+        data: oneOfSchema([jsonValueSchema, stringSchema()]),
+        note: stringSchema()
+      },
+      {
+        title: "OpensteerStructuredBodyPreview",
+        required: ["bytes", "truncated"]
+      }
+    );
+    opensteerNetworkRedirectHopSchema = objectSchema(
       {
-        url: stringSchema({ minLength: 1 }),
-        transport: transportKindSchema,
-        pageRef: pageRefSchema,
-        cookieJar: stringSchema({ minLength: 1 }),
         method: stringSchema({ minLength: 1 }),
-        headers: recordSchema(stringSchema(), {
-          title: "OpensteerRecipeRequestHeaders"
-        }),
-        query: recordSchema(stringSchema(), {
-          title: "OpensteerRecipeRequestQuery"
-        }),
-        body: opensteerRequestBodyInputSchema,
-        followRedirects: { type: "boolean" }
+        status: integerSchema({ minimum: 100, maximum: 599 }),
+        url: stringSchema({ minLength: 1 }),
+        location: stringSchema({ minLength: 1 }),
+        setCookie: arraySchema(stringSchema())
       },
       {
-        title: "OpensteerRecipeRequestStepInput",
-        required: ["url"]
+        title: "OpensteerNetworkRedirectHop",
+        required: ["method", "url"]
       }
     );
-    opensteerRecipeHookRefSchema = objectSchema(
+    opensteerReplayAttemptSchema = objectSchema(
       {
-        specifier: stringSchema({ minLength: 1 }),
-        export: stringSchema({ minLength: 1 })
+        transport: transportKindSchema,
+        status: integerSchema({ minimum: 100, maximum: 599 }),
+        ok: { type: "boolean" },
+        durationMs: integerSchema({ minimum: 0 }),
+        note: stringSchema(),
+        error: stringSchema()
       },
       {
-        title: "OpensteerRecipeHookRef",
-        required: ["specifier", "export"]
+        title: "OpensteerReplayAttempt",
+        required: ["transport", "ok", "durationMs"]
       }
     );
-    opensteerRecipeStepSchema = oneOfSchema(
-      [
-        objectSchema(
+    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(
           {
-            kind: enumSchema(["goto"]),
-            url: stringSchema({ minLength: 1 })
+            operationType: enumSchema(["query", "mutation", "subscription", "unknown"]),
+            operationName: stringSchema({ minLength: 1 }),
+            persisted: { type: "boolean" },
+            variables: jsonValueSchema
           },
           {
-            title: "OpensteerAuthRecipeGotoStep",
-            required: ["kind", "url"]
+            title: "OpensteerGraphqlDetail"
           }
         ),
-        objectSchema(
+        redirectChain: arraySchema(opensteerNetworkRedirectHopSchema),
+        notes: arraySchema(stringSchema()),
+        transportProbe: objectSchema(
           {
-            kind: enumSchema(["reload"])
+            recommended: transportKindSchema,
+            attempts: arraySchema(opensteerReplayAttemptSchema)
           },
           {
-            title: "OpensteerAuthRecipeReloadStep",
-            required: ["kind"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["waitForUrl"]),
-            includes: stringSchema({ minLength: 1 }),
-            timeoutMs: integerSchema({ minimum: 0 })
-          },
-          {
-            title: "OpensteerAuthRecipeWaitForUrlStep",
-            required: ["kind", "includes"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["waitForNetwork"]),
-            url: stringSchema({ minLength: 1 }),
-            hostname: stringSchema({ minLength: 1 }),
-            path: stringSchema({ minLength: 1 }),
-            method: stringSchema({ minLength: 1 }),
-            status: stringSchema({ minLength: 1 }),
-            includeBodies: { type: "boolean" },
-            timeoutMs: integerSchema({ minimum: 0 }),
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerRecipeWaitForNetworkStep",
-            required: ["kind"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["waitForCookie"]),
-            name: stringSchema({ minLength: 1 }),
-            url: stringSchema({ minLength: 1 }),
-            timeoutMs: integerSchema({ minimum: 0 }),
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerAuthRecipeWaitForCookieStep",
-            required: ["kind", "name"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["waitForStorage"]),
-            area: enumSchema(["local", "session"]),
-            origin: stringSchema({ minLength: 1 }),
-            key: stringSchema({ minLength: 1 }),
-            timeoutMs: integerSchema({ minimum: 0 }),
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerAuthRecipeWaitForStorageStep",
-            required: ["kind", "area", "origin", "key"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["readCookie"]),
-            name: stringSchema({ minLength: 1 }),
-            url: stringSchema({ minLength: 1 }),
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerAuthRecipeReadCookieStep",
-            required: ["kind", "name", "saveAs"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["readStorage"]),
-            area: enumSchema(["local", "session"]),
-            origin: stringSchema({ minLength: 1 }),
-            key: stringSchema({ minLength: 1 }),
-            pageUrl: stringSchema({ minLength: 1 }),
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerRecipeReadStorageStep",
-            required: ["kind", "area", "origin", "key", "saveAs"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["evaluate"]),
-            script: stringSchema({ minLength: 1 }),
-            args: arraySchema(jsonValueSchema),
-            pageRef: pageRefSchema,
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerRecipeEvaluateStep",
-            required: ["kind", "script"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["syncCookiesToJar"]),
-            jar: stringSchema({ minLength: 1 }),
-            urls: arraySchema(stringSchema({ minLength: 1 }), {
-              minItems: 1
-            })
-          },
-          {
-            title: "OpensteerRecipeSyncCookiesToJarStep",
-            required: ["kind", "jar"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["request"]),
-            request: opensteerRecipeRequestStepInputSchema,
-            capture: opensteerRecipeStepResponseCaptureSchema
-          },
-          {
-            title: "OpensteerRecipeRequestStep",
-            required: ["kind", "request"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["sessionRequest"]),
-            request: opensteerRecipeRequestStepInputSchema,
-            capture: opensteerRecipeStepResponseCaptureSchema
-          },
-          {
-            title: "OpensteerAuthRecipeSessionRequestStep",
-            required: ["kind", "request"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["directRequest"]),
-            request: opensteerRecipeRequestStepInputSchema,
-            capture: opensteerRecipeStepResponseCaptureSchema
-          },
-          {
-            title: "OpensteerAuthRecipeDirectRequestStep",
-            required: ["kind", "request"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["solveCaptcha"]),
-            provider: captchaProviderSchema,
-            apiKey: stringSchema({ minLength: 1 }),
-            pageRef: pageRefSchema,
-            timeoutMs: integerSchema({ minimum: 1 }),
-            type: captchaTypeSchema,
-            siteKey: stringSchema({ minLength: 1 }),
-            pageUrl: stringSchema({ minLength: 1 }),
-            saveAs: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerRecipeSolveCaptchaStep",
-            required: ["kind", "provider", "apiKey"]
-          }
-        ),
-        objectSchema(
-          {
-            kind: enumSchema(["hook"]),
-            hook: opensteerRecipeHookRefSchema
-          },
-          {
-            title: "OpensteerRecipeHookStep",
-            required: ["kind", "hook"]
+            title: "OpensteerTransportProbeResult",
+            required: ["attempts"]
           }
         )
-      ],
+      },
       {
-        title: "OpensteerRecipeStep"
+        title: "OpensteerNetworkDetailOutput",
+        required: ["recordId", "summary", "requestHeaders", "responseHeaders"]
       }
     );
-    opensteerRecipePayloadSchema = objectSchema(
+    objectSchema(
       {
-        description: stringSchema({ minLength: 1 }),
-        steps: arraySchema(opensteerRecipeStepSchema, {
-          minItems: 1
-        }),
-        outputs: opensteerRecipeRetryOverridesSchema
+        recordId: stringSchema({ minLength: 1 }),
+        pageRef: pageRefSchema,
+        query: opensteerRequestScalarMapSchema,
+        headers: opensteerRequestScalarMapSchema,
+        body: opensteerRequestBodyInputSchema,
+        variables: jsonValueSchema
       },
       {
-        title: "OpensteerRecipePayload",
-        required: ["steps"]
+        title: "OpensteerNetworkReplayInput",
+        required: ["recordId"]
       }
     );
-    opensteerRecipeRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 }),
-        createdAt: integerSchema({ minimum: 0 }),
-        updatedAt: integerSchema({ minimum: 0 }),
-        contentHash: stringSchema({ minLength: 1 }),
-        tags: arraySchema(stringSchema({ minLength: 1 }), {
-          uniqueItems: true
-        }),
-        provenance: opensteerRegistryProvenanceSchema,
-        payload: opensteerRecipePayloadSchema
-      },
+    opensteerSessionFetchTransportSchema = enumSchema(
+      ["auto", "direct", "matched-tls", "context", "page"],
       {
-        title: "OpensteerRecipeRecord",
-        required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
+        title: "OpensteerSessionFetchTransport"
       }
     );
-    opensteerNetworkQueryInputSchema = objectSchema(
+    opensteerSessionFetchInputSchema = objectSchema(
       {
         pageRef: pageRefSchema,
-        recordId: stringSchema({ minLength: 1 }),
-        requestId: stringSchema({ minLength: 1 }),
-        capture: stringSchema({ minLength: 1 }),
-        tag: stringSchema({ minLength: 1 }),
         url: stringSchema({ minLength: 1 }),
-        hostname: stringSchema({ minLength: 1 }),
-        path: stringSchema({ minLength: 1 }),
         method: stringSchema({ minLength: 1 }),
-        status: oneOfSchema([
-          integerSchema({ minimum: 100, maximum: 599 }),
-          stringSchema({ minLength: 1 })
-        ]),
-        resourceType: networkResourceTypeSchema,
-        includeBodies: { type: "boolean" },
-        json: { type: "boolean" },
-        before: stringSchema({ minLength: 1 }),
-        after: stringSchema({ minLength: 1 }),
-        limit: integerSchema({ minimum: 1, maximum: 1e3 })
+        query: opensteerRequestScalarMapSchema,
+        headers: opensteerRequestScalarMapSchema,
+        body: opensteerRequestBodyInputSchema,
+        transport: opensteerSessionFetchTransportSchema,
+        cookies: { type: "boolean" },
+        followRedirects: { type: "boolean" }
       },
       {
-        title: "OpensteerNetworkQueryInput"
+        title: "OpensteerSessionFetchInput",
+        required: ["url"]
       }
     );
-    opensteerGraphqlSummarySchema = objectSchema(
+    opensteerCookieQueryInputSchema = objectSchema(
       {
-        operationType: enumSchema(["query", "mutation", "subscription", "unknown"]),
-        operationName: stringSchema({ minLength: 1 }),
-        persisted: { type: "boolean" }
+        domain: stringSchema({ minLength: 1 })
       },
       {
-        title: "OpensteerGraphqlSummary"
+        title: "OpensteerCookieQueryInput"
       }
     );
-    opensteerNetworkBodySummarySchema = objectSchema(
+    opensteerCookieQueryOutputSchema = objectSchema(
       {
-        bytes: integerSchema({ minimum: 0 }),
-        contentType: stringSchema({ minLength: 1 }),
-        streaming: { type: "boolean" }
+        domain: stringSchema({ minLength: 1 }),
+        cookies: arraySchema(cookieRecordSchema)
       },
       {
-        title: "OpensteerNetworkBodySummary"
+        title: "OpensteerCookieQueryOutput",
+        required: ["cookies"]
       }
     );
-    opensteerNetworkSummaryRecordSchema = objectSchema(
+    opensteerStorageDomainSnapshotSchema = 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"
-          }
-        )
+        domain: stringSchema({ minLength: 1 }),
+        localStorage: arraySchema(storageEntrySchema),
+        sessionStorage: arraySchema(storageEntrySchema)
       },
       {
-        title: "OpensteerNetworkSummaryRecord",
-        required: ["recordId", "kind", "method", "resourceType", "url"]
+        title: "OpensteerStorageDomainSnapshot",
+        required: ["domain", "localStorage", "sessionStorage"]
       }
     );
-    opensteerNetworkQueryOutputSchema = objectSchema(
+    opensteerStorageQueryInputSchema = objectSchema(
       {
-        records: arraySchema(opensteerNetworkSummaryRecordSchema)
+        domain: stringSchema({ minLength: 1 })
       },
       {
-        title: "OpensteerNetworkQueryOutput",
-        required: ["records"]
+        title: "OpensteerStorageQueryInput"
       }
     );
-    opensteerNetworkDetailInputSchema = objectSchema(
+    opensteerStorageQueryOutputSchema = objectSchema(
       {
-        recordId: stringSchema({ minLength: 1 }),
-        probe: { type: "boolean" }
+        domains: arraySchema(opensteerStorageDomainSnapshotSchema)
       },
       {
-        title: "OpensteerNetworkDetailInput",
-        required: ["recordId"]
+        title: "OpensteerStorageQueryOutput",
+        required: ["domains"]
       }
     );
-    opensteerParsedCookieSchema = objectSchema(
+    opensteerHiddenFieldSchema = objectSchema(
       {
+        path: stringSchema({ minLength: 1 }),
         name: stringSchema({ minLength: 1 }),
         value: stringSchema()
       },
       {
-        title: "OpensteerParsedCookie",
-        required: ["name", "value"]
+        title: "OpensteerHiddenField",
+        required: ["path", "name", "value"]
       }
     );
-    opensteerStructuredBodyPreviewSchema = objectSchema(
+    opensteerStateDomainSnapshotSchema = objectSchema(
       {
-        contentType: stringSchema({ minLength: 1 }),
-        bytes: integerSchema({ minimum: 0 }),
-        truncated: { type: "boolean" },
-        data: oneOfSchema([jsonValueSchema, stringSchema()]),
-        note: stringSchema()
+        domain: stringSchema({ minLength: 1 }),
+        cookies: arraySchema(cookieRecordSchema),
+        hiddenFields: arraySchema(opensteerHiddenFieldSchema),
+        localStorage: arraySchema(storageEntrySchema),
+        sessionStorage: arraySchema(storageEntrySchema),
+        globals: recordSchema(jsonValueSchema)
       },
       {
-        title: "OpensteerStructuredBodyPreview",
-        required: ["bytes", "truncated"]
+        title: "OpensteerStateDomainSnapshot",
+        required: ["domain", "cookies", "hiddenFields", "localStorage", "sessionStorage"]
       }
     );
-    opensteerNetworkRedirectHopSchema = objectSchema(
+    opensteerStateQueryInputSchema = objectSchema(
       {
-        method: stringSchema({ minLength: 1 }),
-        status: integerSchema({ minimum: 100, maximum: 599 }),
-        url: stringSchema({ minLength: 1 }),
-        location: stringSchema({ minLength: 1 }),
-        setCookie: arraySchema(stringSchema())
+        domain: stringSchema({ minLength: 1 })
       },
       {
-        title: "OpensteerNetworkRedirectHop",
-        required: ["method", "url"]
+        title: "OpensteerStateQueryInput"
       }
     );
-    opensteerReplayAttemptSchema = objectSchema(
+    opensteerStateQueryOutputSchema = objectSchema(
       {
-        transport: transportKindSchema,
-        status: integerSchema({ minimum: 100, maximum: 599 }),
-        ok: { type: "boolean" },
-        durationMs: integerSchema({ minimum: 0 }),
-        note: stringSchema(),
-        error: stringSchema()
+        domains: arraySchema(opensteerStateDomainSnapshotSchema)
       },
       {
-        title: "OpensteerReplayAttempt",
-        required: ["transport", "ok", "durationMs"]
+        title: "OpensteerStateQueryOutput",
+        required: ["domains"]
       }
     );
-    opensteerNetworkDetailOutputSchema = objectSchema(
+    objectSchema(
       {
+        pageRef: pageRefSchema,
         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"]
-      }
-    );
-    objectSchema(
-      {
-        recordId: stringSchema({ minLength: 1 }),
-        pageRef: pageRefSchema,
-        query: opensteerRequestScalarMapSchema,
-        headers: opensteerRequestScalarMapSchema,
-        body: opensteerRequestBodyInputSchema,
-        variables: jsonValueSchema
-      },
-      {
-        title: "OpensteerNetworkReplayInput",
-        required: ["recordId"]
-      }
-    );
-    opensteerSessionFetchTransportSchema = enumSchema(
-      ["auto", "direct", "matched-tls", "context", "page"],
-      {
-        title: "OpensteerSessionFetchTransport"
-      }
-    );
-    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"]
-      }
-    );
-    opensteerCookieQueryInputSchema = objectSchema(
-      {
-        domain: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerCookieQueryInput"
-      }
-    );
-    opensteerCookieQueryOutputSchema = objectSchema(
-      {
-        domain: stringSchema({ minLength: 1 }),
-        cookies: arraySchema(cookieRecordSchema)
-      },
-      {
-        title: "OpensteerCookieQueryOutput",
-        required: ["cookies"]
-      }
-    );
-    opensteerStorageDomainSnapshotSchema = objectSchema(
-      {
-        domain: stringSchema({ minLength: 1 }),
-        localStorage: arraySchema(storageEntrySchema),
-        sessionStorage: arraySchema(storageEntrySchema)
-      },
-      {
-        title: "OpensteerStorageDomainSnapshot",
-        required: ["domain", "localStorage", "sessionStorage"]
-      }
-    );
-    opensteerStorageQueryInputSchema = objectSchema(
-      {
-        domain: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerStorageQueryInput"
-      }
-    );
-    opensteerStorageQueryOutputSchema = objectSchema(
-      {
-        domains: arraySchema(opensteerStorageDomainSnapshotSchema)
-      },
-      {
-        title: "OpensteerStorageQueryOutput",
-        required: ["domains"]
-      }
-    );
-    opensteerHiddenFieldSchema = objectSchema(
-      {
-        path: stringSchema({ minLength: 1 }),
-        name: stringSchema({ minLength: 1 }),
-        value: stringSchema()
-      },
-      {
-        title: "OpensteerHiddenField",
-        required: ["path", "name", "value"]
-      }
-    );
-    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"]
-      }
-    );
-    opensteerStateQueryInputSchema = objectSchema(
-      {
-        domain: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerStateQueryInput"
-      }
-    );
-    opensteerStateQueryOutputSchema = objectSchema(
-      {
-        domains: arraySchema(opensteerStateDomainSnapshotSchema)
-      },
-      {
-        title: "OpensteerStateQueryOutput",
-        required: ["domains"]
-      }
-    );
-    objectSchema(
-      {
-        pageRef: pageRefSchema,
-        recordId: stringSchema({ minLength: 1 }),
-        requestId: stringSchema({ minLength: 1 }),
+        requestId: stringSchema({ minLength: 1 }),
         capture: stringSchema({ minLength: 1 }),
         tag: stringSchema({ minLength: 1 }),
         url: stringSchema({ minLength: 1 }),
@@ -4351,85 +3935,6 @@ var init_requests = __esm({
         required: ["plans"]
       }
     );
-    objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 }),
-        tags: arraySchema(stringSchema({ minLength: 1 }), {
-          uniqueItems: true
-        }),
-        provenance: opensteerRegistryProvenanceSchema,
-        payload: opensteerRecipePayloadSchema
-      },
-      {
-        title: "OpensteerWriteRecipeInput",
-        required: ["key", "version", "payload"]
-      }
-    );
-    objectSchema(
-      {
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerGetRecipeInput",
-        required: ["key"]
-      }
-    );
-    objectSchema(
-      {
-        key: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerListRecipesInput"
-      }
-    );
-    objectSchema(
-      {
-        recipes: arraySchema(opensteerRecipeRecordSchema)
-      },
-      {
-        title: "OpensteerListRecipesOutput",
-        required: ["recipes"]
-      }
-    );
-    objectSchema(
-      {
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 }),
-        variables: recordSchema(stringSchema(), {
-          title: "OpensteerRecipeVariables"
-        })
-      },
-      {
-        title: "OpensteerRunRecipeInput",
-        required: ["key"]
-      }
-    );
-    objectSchema(
-      {
-        recipe: objectSchema(
-          {
-            id: stringSchema({ minLength: 1 }),
-            key: stringSchema({ minLength: 1 }),
-            version: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerResolvedRecipeRef",
-            required: ["id", "key", "version"]
-          }
-        ),
-        variables: recordSchema(stringSchema(), {
-          title: "OpensteerResolvedRecipeVariables"
-        }),
-        overrides: opensteerRecipeRetryOverridesSchema
-      },
-      {
-        title: "OpensteerRunRecipeOutput",
-        required: ["recipe", "variables"]
-      }
-    );
     objectSchema(
       {
         key: stringSchema({ minLength: 1 }),
@@ -4536,17 +4041,7 @@ var init_requests = __esm({
           {
             attempted: { type: "boolean" },
             succeeded: { type: "boolean" },
-            matchedFailurePolicy: { type: "boolean" },
-            recipe: objectSchema(
-              {
-                key: stringSchema({ minLength: 1 }),
-                version: stringSchema({ minLength: 1 })
-              },
-              {
-                title: "OpensteerResolvedRecoveryRecipeRef",
-                required: ["key", "version"]
-              }
-            )
+            matchedFailurePolicy: { type: "boolean" }
           },
           {
             title: "OpensteerRequestRecoveryMetadata",
@@ -4587,29 +4082,100 @@ var init_requests = __esm({
   }
 });
 
-// ../protocol/src/snapshots.ts
-var screenshotFormatSchema, screenshotArtifactSchema, htmlSnapshotSchema, domSnapshotNodeSchema, shadowDomSnapshotModeSchema, domSnapshotSchema, hitTestResultSchema;
-var init_snapshots2 = __esm({
-  "../protocol/src/snapshots.ts"() {
-    init_identity2();
-    init_binary_location();
-    init_geometry2();
+// ../protocol/src/state.ts
+var opensteerStateSnapshotCookieSchema, opensteerStateSnapshotSchema, opensteerStateDeltaSchema;
+var init_state = __esm({
+  "../protocol/src/state.ts"() {
     init_json2();
-    screenshotFormatSchema = enumSchema(["png", "jpeg", "webp"], {
-      title: "ScreenshotFormat"
-    });
-    screenshotArtifactSchema = objectSchema(
-      {
-        pageRef: pageRefSchema,
-        frameRef: frameRefSchema,
-        documentRef: documentRefSchema,
-        documentEpoch: documentEpochSchema,
-        payload: externalBinaryLocationSchema,
-        format: screenshotFormatSchema,
-        size: sizeSchema,
-        coordinateSpace: coordinateSpaceSchema,
-        clip: rectSchema
-      },
+    init_identity2();
+    init_storage2();
+    opensteerStateSnapshotCookieSchema = objectSchema(
+      {
+        name: stringSchema({ minLength: 1 }),
+        value: stringSchema(),
+        domain: stringSchema({ minLength: 1 }),
+        path: stringSchema({ minLength: 1 }),
+        secure: { type: "boolean" },
+        httpOnly: { type: "boolean" },
+        sameSite: enumSchema(["strict", "lax", "none"]),
+        priority: enumSchema(["low", "medium", "high"]),
+        partitionKey: stringSchema({ minLength: 1 }),
+        session: { type: "boolean" },
+        expiresAt: oneOfSchema([integerSchema({ minimum: 0 }), { type: "null" }])
+      },
+      {
+        title: "OpensteerStateSnapshotCookie",
+        required: ["name", "value", "domain", "path", "secure", "httpOnly", "session"]
+      }
+    );
+    opensteerStateSnapshotSchema = objectSchema(
+      {
+        id: stringSchema({ minLength: 1 }),
+        capturedAt: integerSchema({ minimum: 0 }),
+        pageRef: pageRefSchema,
+        url: stringSchema({ minLength: 1 }),
+        cookies: arraySchema(opensteerStateSnapshotCookieSchema),
+        storage: storageSnapshotSchema,
+        hiddenFields: arraySchema(
+          objectSchema(
+            {
+              path: stringSchema({ minLength: 1 }),
+              name: stringSchema({ minLength: 1 }),
+              value: stringSchema()
+            },
+            {
+              title: "OpensteerStateSnapshotHiddenField",
+              required: ["path", "name", "value"]
+            }
+          )
+        ),
+        globals: recordSchema({}, { title: "OpensteerStateSnapshotGlobals" })
+      },
+      {
+        title: "OpensteerStateSnapshot",
+        required: ["id", "capturedAt"]
+      }
+    );
+    opensteerStateDeltaSchema = objectSchema(
+      {
+        beforeStateId: stringSchema({ minLength: 1 }),
+        afterStateId: stringSchema({ minLength: 1 }),
+        cookiesChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+        storageChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+        hiddenFieldsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+        globalsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
+      },
+      {
+        title: "OpensteerStateDelta",
+        required: ["cookiesChanged", "storageChanged", "hiddenFieldsChanged", "globalsChanged"]
+      }
+    );
+  }
+});
+
+// ../protocol/src/snapshots.ts
+var screenshotFormatSchema, screenshotArtifactSchema, htmlSnapshotSchema, domSnapshotNodeSchema, shadowDomSnapshotModeSchema, domSnapshotSchema, hitTestResultSchema;
+var init_snapshots2 = __esm({
+  "../protocol/src/snapshots.ts"() {
+    init_identity2();
+    init_binary_location();
+    init_geometry2();
+    init_json2();
+    screenshotFormatSchema = enumSchema(["png", "jpeg", "webp"], {
+      title: "ScreenshotFormat"
+    });
+    screenshotArtifactSchema = objectSchema(
+      {
+        pageRef: pageRefSchema,
+        frameRef: frameRefSchema,
+        documentRef: documentRefSchema,
+        documentEpoch: documentEpochSchema,
+        payload: externalBinaryLocationSchema,
+        format: screenshotFormatSchema,
+        size: sizeSchema,
+        coordinateSpace: coordinateSpaceSchema,
+        clip: rectSchema
+      },
       {
         title: "ScreenshotArtifact",
         required: ["pageRef", "payload", "format", "size", "coordinateSpace"]
@@ -5491,6 +5057,62 @@ var init_artifacts2 = __esm({
   }
 });
 
+// ../protocol/src/captcha.ts
+var captchaTypeSchema, captchaProviderSchema, captchaDetectionResultSchema, opensteerCaptchaSolveInputSchema, opensteerCaptchaSolveOutputSchema;
+var init_captcha = __esm({
+  "../protocol/src/captcha.ts"() {
+    init_json2();
+    init_identity2();
+    captchaTypeSchema = enumSchema(
+      ["recaptcha-v2", "hcaptcha", "turnstile"],
+      {
+        title: "CaptchaType"
+      }
+    );
+    captchaProviderSchema = enumSchema(["2captcha", "capsolver"], {
+      title: "CaptchaProvider"
+    });
+    captchaDetectionResultSchema = objectSchema(
+      {
+        type: captchaTypeSchema,
+        siteKey: stringSchema({ minLength: 1 }),
+        pageUrl: stringSchema({ minLength: 1 })
+      },
+      {
+        title: "CaptchaDetectionResult",
+        required: ["type", "siteKey", "pageUrl"]
+      }
+    );
+    opensteerCaptchaSolveInputSchema = objectSchema(
+      {
+        provider: captchaProviderSchema,
+        apiKey: stringSchema({ minLength: 1 }),
+        pageRef: pageRefSchema,
+        timeoutMs: integerSchema({ minimum: 1 }),
+        type: captchaTypeSchema,
+        siteKey: stringSchema({ minLength: 1 }),
+        pageUrl: stringSchema({ minLength: 1 })
+      },
+      {
+        title: "OpensteerCaptchaSolveInput",
+        required: ["provider", "apiKey"]
+      }
+    );
+    opensteerCaptchaSolveOutputSchema = objectSchema(
+      {
+        captcha: captchaDetectionResultSchema,
+        token: stringSchema({ minLength: 1 }),
+        injected: { type: "boolean" },
+        provider: captchaProviderSchema
+      },
+      {
+        title: "OpensteerCaptchaSolveOutput",
+        required: ["captcha", "token", "injected", "provider"]
+      }
+    );
+  }
+});
+
 // ../protocol/src/traces.ts
 function traceRecordSchema(dataSchema = {}) {
   return objectSchema(
@@ -6668,1627 +6290,75 @@ var init_scripts = __esm({
             body: stringSchema()
           },
           {
-            title: "SandboxAjaxMockResponse",
-            required: ["status"]
-          }
-        )
-      },
-      {
-        title: "SandboxAjaxRoute",
-        required: ["urlPattern", "mode"]
-      }
-    );
-    opensteerScriptSandboxInputSchema = objectSchema(
-      {
-        artifactId: stringSchema({ minLength: 1 }),
-        content: stringSchema(),
-        fidelity: sandboxFidelitySchema,
-        ajaxRoutes: arraySchema(sandboxAjaxRouteSchema),
-        cookies: recordSchema(stringSchema(), {
-          title: "SandboxCookies"
-        }),
-        globals: objectSchema(
-          {},
-          {
-            title: "SandboxGlobals",
-            additionalProperties: true
-          }
-        ),
-        timeoutMs: integerSchema({ minimum: 1 }),
-        clockMode: enumSchema(["real", "manual"])
-      },
-      {
-        title: "OpensteerScriptSandboxInput"
-      }
-    );
-    sandboxCapturedAjaxCallSchema = objectSchema(
-      {
-        method: stringSchema({ minLength: 1 }),
-        url: stringSchema({ minLength: 1 }),
-        headers: recordSchema(stringSchema(), {
-          title: "SandboxCapturedAjaxHeaders"
-        }),
-        body: stringSchema(),
-        timestamp: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "SandboxCapturedAjaxCall",
-        required: ["method", "url", "headers", "timestamp"]
-      }
-    );
-    opensteerScriptSandboxOutputSchema = objectSchema(
-      {
-        result: oneOfSchema(
-          [
-            objectSchema({}, { additionalProperties: true }),
-            arraySchema({}),
-            stringSchema(),
-            { type: "number" },
-            enumSchema([true, false, null])
-          ],
-          {
-            title: "SandboxResult"
-          }
-        ),
-        capturedAjax: arraySchema(sandboxCapturedAjaxCallSchema),
-        errors: arraySchema(stringSchema({ minLength: 1 })),
-        durationMs: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerScriptSandboxOutput",
-        required: ["capturedAjax", "errors", "durationMs"]
-      }
-    );
-  }
-});
-
-// ../protocol/src/reverse.ts
-var opensteerStateSourceKindSchema, opensteerReverseCaseStatusSchema, opensteerReverseChannelKindSchema, opensteerReverseManualCalibrationModeSchema, opensteerReverseCandidateBoundarySchema, opensteerReverseAdvisoryTagSchema, opensteerReverseConstraintKindSchema, opensteerRequestInputLocationSchema, opensteerRequestInputRequirednessSchema, opensteerRequestInputClassificationSchema, opensteerRequestInputSourceSchema, opensteerRequestInputMaterializationPolicySchema, opensteerRequestInputExportPolicySchema, opensteerReverseQueryViewSchema, opensteerReverseSortKeySchema, opensteerReverseSortPresetSchema, opensteerReverseSortDirectionSchema, opensteerObservationClusterRelationshipKindSchema, opensteerReverseReportKindSchema, opensteerReversePackageKindSchema, opensteerReversePackageReadinessSchema, opensteerBodyCodecKindSchema, opensteerExecutableResolverKindSchema, opensteerValueReferenceKindSchema, opensteerRuntimeValueKeySchema, opensteerValidationRuleKindSchema, opensteerReverseRequirementKindSchema, opensteerReverseRequirementStatusSchema, opensteerReverseSuggestedEditKindSchema, jsonValueSchema2, opensteerValueReferenceSchema, opensteerValueTemplateSchema, opensteerReverseTargetHintsSchema, opensteerBodyCodecDescriptorSchema, opensteerObservationClusterSchema, opensteerStateSnapshotCookieSchema, opensteerStateSnapshotSchema, opensteerStateDeltaSchema, opensteerRequestInputDescriptorSchema, opensteerExecutableResolverSchema, opensteerReverseAdvisorySignalsSchema, opensteerValidationRuleSchema, opensteerChannelDescriptorSchema, opensteerReverseOperationWorkflowStepSchema, opensteerReverseAwaitRecordWorkflowStepSchema, opensteerReverseAssertWorkflowStepSchema, opensteerReverseWorkflowStepSchema, opensteerReversePackageRequirementsSchema, opensteerReverseAdvisoryTemplateSchema, opensteerReverseGuardRecordSchema, opensteerReverseObservationRecordSchema, opensteerReverseObservedRecordSchema, opensteerReverseCandidateRecordSchema, opensteerReverseReplayValidationSchema, opensteerReverseReplayRunRecordSchema, opensteerReverseExperimentRecordSchema, opensteerReverseRequirementSchema, opensteerReverseSuggestedEditSchema, opensteerReverseExportRecordSchema, opensteerReverseCasePayloadSchema, opensteerReversePackagePayloadSchema, opensteerReversePackageRecordSchema, opensteerReverseCandidateReportItemSchema, opensteerReverseDiscoverySummaryCountsSchema, opensteerReverseReportPayloadSchema, opensteerReverseReportRecordSchema, opensteerReverseNetworkFilterSchema, opensteerReverseQueryFiltersSchema, opensteerReverseQuerySortSchema, opensteerReverseQuerySnapshotSchema, opensteerReverseQueryRecordItemSchema, opensteerReverseQueryClusterItemSchema, opensteerReverseQueryCandidateItemSchema;
-var init_reverse = __esm({
-  "../protocol/src/reverse.ts"() {
-    init_json2();
-    init_identity2();
-    init_network2();
-    init_requests();
-    init_storage2();
-    opensteerStateSourceKindSchema = enumSchema(
-      ["temporary", "persistent", "attach"],
-      { title: "OpensteerStateSourceKind" }
-    );
-    opensteerReverseCaseStatusSchema = enumSchema(
-      ["capturing", "analyzing", "ready", "attention"],
-      { title: "OpensteerReverseCaseStatus" }
-    );
-    opensteerReverseChannelKindSchema = enumSchema(
-      ["http", "event-stream", "websocket"],
-      { title: "OpensteerReverseChannelKind" }
-    );
-    opensteerReverseManualCalibrationModeSchema = enumSchema(
-      ["allow", "avoid", "require"],
-      { title: "OpensteerReverseManualCalibrationMode" }
-    );
-    opensteerReverseCandidateBoundarySchema = enumSchema(
-      ["first-party", "same-site", "third-party"],
-      { title: "OpensteerReverseCandidateBoundary" }
-    );
-    opensteerReverseAdvisoryTagSchema = enumSchema(
-      [
-        "data",
-        "facet",
-        "telemetry",
-        "subscription",
-        "navigation",
-        "document",
-        "route-data",
-        "search",
-        "tracking",
-        "unknown"
-      ],
-      { title: "OpensteerReverseAdvisoryTag" }
-    );
-    opensteerReverseConstraintKindSchema = enumSchema(
-      [
-        "requires-browser",
-        "requires-cookie",
-        "requires-storage",
-        "requires-script",
-        "requires-guard",
-        "requires-live-state",
-        "opaque-body",
-        "unsupported"
-      ],
-      { title: "OpensteerReverseConstraintKind" }
-    );
-    opensteerRequestInputLocationSchema = enumSchema(
-      ["path", "query", "header", "cookie", "body-field"],
-      { title: "OpensteerRequestInputLocation" }
-    );
-    opensteerRequestInputRequirednessSchema = enumSchema(
-      ["required", "optional", "unknown"],
-      { title: "OpensteerRequestInputRequiredness" }
-    );
-    opensteerRequestInputClassificationSchema = enumSchema(
-      ["managed", "static", "contextual", "volatile"],
-      { title: "OpensteerRequestInputClassification" }
-    );
-    opensteerRequestInputSourceSchema = enumSchema(
-      [
-        "literal",
-        "cookie",
-        "storage",
-        "prior-response",
-        "page",
-        "script",
-        "guard-output",
-        "runtime-managed",
-        "unknown"
-      ],
-      { title: "OpensteerRequestInputSource" }
-    );
-    opensteerRequestInputMaterializationPolicySchema = enumSchema(
-      ["copy", "omit", "recompute", "resolve"],
-      { title: "OpensteerRequestInputMaterializationPolicy" }
-    );
-    opensteerRequestInputExportPolicySchema = enumSchema(
-      ["portable", "browser-bound", "blocked"],
-      { title: "OpensteerRequestInputExportPolicy" }
-    );
-    opensteerReverseQueryViewSchema = enumSchema(
-      ["records", "clusters", "candidates"],
-      { title: "OpensteerReverseQueryView" }
-    );
-    opensteerReverseSortKeySchema = enumSchema(
-      [
-        "observed-at",
-        "advisory-rank",
-        "target-hint-matches",
-        "response-richness",
-        "portability",
-        "boundary",
-        "success"
-      ],
-      { title: "OpensteerReverseSortKey" }
-    );
-    opensteerReverseSortPresetSchema = enumSchema(
-      [
-        "advisory-rank",
-        "observed-at",
-        "portability",
-        "first-party",
-        "hint-match",
-        "response-richness"
-      ],
-      { title: "OpensteerReverseSortPreset" }
-    );
-    opensteerReverseSortDirectionSchema = enumSchema(
-      ["asc", "desc"],
-      {
-        title: "OpensteerReverseSortDirection"
-      }
-    );
-    opensteerObservationClusterRelationshipKindSchema = enumSchema(
-      ["seed", "preflight", "redirect", "retry", "duplicate", "follow-on"],
-      { title: "OpensteerObservationClusterRelationshipKind" }
-    );
-    opensteerReverseReportKindSchema = enumSchema(
-      ["discovery", "package"],
-      { title: "OpensteerReverseReportKind" }
-    );
-    opensteerReversePackageKindSchema = enumSchema(
-      ["portable-http", "browser-workflow"],
-      { title: "OpensteerReversePackageKind" }
-    );
-    opensteerReversePackageReadinessSchema = enumSchema(
-      ["runnable", "draft", "unsupported"],
-      { title: "OpensteerReversePackageReadiness" }
-    );
-    opensteerBodyCodecKindSchema = enumSchema(
-      [
-        "json",
-        "form-urlencoded",
-        "multipart",
-        "graphql",
-        "persisted-graphql",
-        "text",
-        "opaque-binary",
-        "sse",
-        "websocket-json",
-        "websocket-text",
-        "unknown"
-      ],
-      { title: "OpensteerBodyCodecKind" }
-    );
-    opensteerExecutableResolverKindSchema = enumSchema(
-      [
-        "literal",
-        "cookie",
-        "storage",
-        "prior-record",
-        "binding",
-        "candidate",
-        "case",
-        "state-snapshot",
-        "artifact",
-        "manual",
-        "runtime-managed"
-      ],
-      { title: "OpensteerExecutableResolverKind" }
-    );
-    opensteerValueReferenceKindSchema = enumSchema(
-      [
-        "literal",
-        "resolver",
-        "binding",
-        "candidate",
-        "case",
-        "record",
-        "artifact",
-        "state-snapshot",
-        "runtime",
-        "manual"
-      ],
-      { title: "OpensteerValueReferenceKind" }
-    );
-    opensteerRuntimeValueKeySchema = enumSchema(
-      ["pageRef", "packageId", "caseId", "candidateId", "objective"],
-      { title: "OpensteerRuntimeValueKey" }
-    );
-    opensteerValidationRuleKindSchema = enumSchema(
-      [
-        "status",
-        "json-structure",
-        "text-includes",
-        "stream-first-chunk",
-        "websocket-open",
-        "message-count-at-least"
-      ],
-      { title: "OpensteerValidationRuleKind" }
-    );
-    enumSchema(
-      ["operation", "await-record", "assert"],
-      { title: "OpensteerReverseWorkflowStepKind" }
-    );
-    opensteerReverseRequirementKindSchema = enumSchema(
-      ["resolver", "guard", "workflow-step", "state", "channel", "unsupported"],
-      { title: "OpensteerReverseRequirementKind" }
-    );
-    opensteerReverseRequirementStatusSchema = enumSchema(
-      ["required", "recommended"],
-      { title: "OpensteerReverseRequirementStatus" }
-    );
-    opensteerReverseSuggestedEditKindSchema = enumSchema(
-      [
-        "set-resolver",
-        "attach-trace",
-        "replace-workflow",
-        "patch-step-input",
-        "switch-state-source",
-        "inspect-evidence",
-        "mark-unsupported"
-      ],
-      { title: "OpensteerReverseSuggestedEditKind" }
-    );
-    jsonValueSchema2 = defineSchema({
-      title: "JsonValue"
-    });
-    opensteerValueReferenceSchema = objectSchema(
-      {
-        kind: opensteerValueReferenceKindSchema,
-        pointer: stringSchema({ minLength: 1 }),
-        resolverId: stringSchema({ minLength: 1 }),
-        binding: stringSchema({ minLength: 1 }),
-        recordId: stringSchema({ minLength: 1 }),
-        artifactId: stringSchema({ minLength: 1 }),
-        stateSnapshotId: stringSchema({ minLength: 1 }),
-        runtimeKey: opensteerRuntimeValueKeySchema,
-        value: jsonValueSchema2,
-        placeholder: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerValueReference",
-        required: ["kind"]
-      }
-    );
-    opensteerValueTemplateSchema = defineSchema({
-      title: "OpensteerValueTemplate"
-    });
-    opensteerReverseTargetHintsSchema = objectSchema(
-      {
-        hosts: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        paths: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        operationNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        channels: arraySchema(opensteerReverseChannelKindSchema, { uniqueItems: true })
-      },
-      {
-        title: "OpensteerReverseTargetHints"
-      }
-    );
-    opensteerBodyCodecDescriptorSchema = objectSchema(
-      {
-        kind: opensteerBodyCodecKindSchema,
-        contentType: stringSchema({ minLength: 1 }),
-        operationName: stringSchema({ minLength: 1 }),
-        fieldPaths: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-      },
-      {
-        title: "OpensteerBodyCodecDescriptor",
-        required: ["kind", "fieldPaths"]
-      }
-    );
-    opensteerObservationClusterSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        observationId: stringSchema({ minLength: 1 }),
-        label: stringSchema({ minLength: 1 }),
-        channel: opensteerReverseChannelKindSchema,
-        method: stringSchema({ minLength: 1 }),
-        url: stringSchema({ minLength: 1 }),
-        matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        members: arraySchema(
-          objectSchema(
-            {
-              recordId: stringSchema({ minLength: 1 }),
-              observedAt: integerSchema({ minimum: 0 }),
-              resourceType: stringSchema({ minLength: 1 }),
-              status: integerSchema({ minimum: 0 }),
-              relation: opensteerObservationClusterRelationshipKindSchema,
-              relatedRecordId: stringSchema({ minLength: 1 }),
-              matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-            },
-            {
-              title: "OpensteerObservationClusterMember",
-              required: ["recordId", "relation", "matchedTargetHints"]
-            }
-          )
-        )
-      },
-      {
-        title: "OpensteerObservationCluster",
-        required: ["id", "observationId", "label", "channel", "url", "matchedTargetHints", "members"]
-      }
-    );
-    opensteerStateSnapshotCookieSchema = objectSchema(
-      {
-        name: stringSchema({ minLength: 1 }),
-        value: stringSchema(),
-        domain: stringSchema({ minLength: 1 }),
-        path: stringSchema({ minLength: 1 }),
-        secure: { type: "boolean" },
-        httpOnly: { type: "boolean" },
-        sameSite: enumSchema(["strict", "lax", "none"]),
-        priority: enumSchema(["low", "medium", "high"]),
-        partitionKey: stringSchema({ minLength: 1 }),
-        session: { type: "boolean" },
-        expiresAt: oneOfSchema([integerSchema({ minimum: 0 }), { type: "null" }])
-      },
-      {
-        title: "OpensteerStateSnapshotCookie",
-        required: ["name", "value", "domain", "path", "secure", "httpOnly", "session"]
-      }
-    );
-    opensteerStateSnapshotSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        capturedAt: integerSchema({ minimum: 0 }),
-        pageRef: pageRefSchema,
-        url: stringSchema({ minLength: 1 }),
-        cookies: arraySchema(opensteerStateSnapshotCookieSchema),
-        storage: storageSnapshotSchema,
-        hiddenFields: arraySchema(
-          objectSchema(
-            {
-              path: stringSchema({ minLength: 1 }),
-              name: stringSchema({ minLength: 1 }),
-              value: stringSchema()
-            },
-            {
-              title: "OpensteerStateSnapshotHiddenField",
-              required: ["path", "name", "value"]
-            }
-          )
-        ),
-        globals: recordSchema({}, { title: "OpensteerStateSnapshotGlobals" })
-      },
-      {
-        title: "OpensteerStateSnapshot",
-        required: ["id", "capturedAt"]
-      }
-    );
-    opensteerStateDeltaSchema = objectSchema(
-      {
-        beforeStateId: stringSchema({ minLength: 1 }),
-        afterStateId: stringSchema({ minLength: 1 }),
-        cookiesChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        storageChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        hiddenFieldsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        globalsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-      },
-      {
-        title: "OpensteerStateDelta",
-        required: ["cookiesChanged", "storageChanged", "hiddenFieldsChanged", "globalsChanged"]
-      }
-    );
-    opensteerRequestInputDescriptorSchema = objectSchema(
-      {
-        name: stringSchema({ minLength: 1 }),
-        location: opensteerRequestInputLocationSchema,
-        path: stringSchema({ minLength: 1 }),
-        wireName: stringSchema({ minLength: 1 }),
-        requiredness: opensteerRequestInputRequirednessSchema,
-        classification: opensteerRequestInputClassificationSchema,
-        source: opensteerRequestInputSourceSchema,
-        materializationPolicy: opensteerRequestInputMaterializationPolicySchema,
-        exportPolicy: opensteerRequestInputExportPolicySchema,
-        originalValue: stringSchema(),
-        provenance: objectSchema(
-          {
-            recordId: stringSchema({ minLength: 1 }),
-            observationId: stringSchema({ minLength: 1 }),
-            sourcePointer: stringSchema({ minLength: 1 }),
-            notes: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerRequestInputDescriptorProvenance"
-          }
-        ),
-        unlockedByGuardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-      },
-      {
-        title: "OpensteerRequestInputDescriptor",
-        required: [
-          "name",
-          "location",
-          "requiredness",
-          "classification",
-          "source",
-          "materializationPolicy",
-          "exportPolicy"
-        ]
-      }
-    );
-    opensteerExecutableResolverSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        kind: opensteerExecutableResolverKindSchema,
-        label: stringSchema({ minLength: 1 }),
-        status: enumSchema(["ready", "missing"]),
-        requiresBrowser: { type: "boolean" },
-        requiresLiveState: { type: "boolean" },
-        description: stringSchema({ minLength: 1 }),
-        inputNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        guardId: stringSchema({ minLength: 1 }),
-        traceId: stringSchema({ minLength: 1 }),
-        valueRef: opensteerValueReferenceSchema
-      },
-      {
-        title: "OpensteerExecutableResolver",
-        required: ["id", "kind", "label", "status", "requiresBrowser", "requiresLiveState"]
-      }
-    );
-    opensteerReverseAdvisorySignalsSchema = objectSchema(
-      {
-        advisoryRank: numberSchema(),
-        observedAt: integerSchema({ minimum: 0 }),
-        targetHintMatches: integerSchema({ minimum: 0 }),
-        responseRichness: integerSchema({ minimum: 0 }),
-        portabilityWeight: integerSchema({ minimum: 0 }),
-        boundaryWeight: integerSchema({ minimum: 0 }),
-        successfulStatus: { type: "boolean" },
-        fetchLike: { type: "boolean" },
-        hasResponseBody: { type: "boolean" },
-        dataPathMatch: { type: "boolean" },
-        cookieInputCount: integerSchema({ minimum: 0 }),
-        storageInputCount: integerSchema({ minimum: 0 }),
-        volatileInputCount: integerSchema({ minimum: 0 }),
-        guardCount: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerReverseAdvisorySignals",
-        required: [
-          "advisoryRank",
-          "targetHintMatches",
-          "responseRichness",
-          "portabilityWeight",
-          "boundaryWeight",
-          "successfulStatus",
-          "fetchLike",
-          "hasResponseBody",
-          "dataPathMatch",
-          "cookieInputCount",
-          "storageInputCount",
-          "volatileInputCount",
-          "guardCount"
-        ]
-      }
-    );
-    opensteerValidationRuleSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        kind: opensteerValidationRuleKindSchema,
-        label: stringSchema({ minLength: 1 }),
-        required: { type: "boolean" },
-        expectedStatus: integerSchema({ minimum: 0 }),
-        structureHash: stringSchema({ minLength: 1 }),
-        textIncludes: stringSchema({ minLength: 1 }),
-        minimumCount: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerValidationRule",
-        required: ["id", "kind", "label", "required"]
-      }
-    );
-    opensteerChannelDescriptorSchema = objectSchema(
-      {
-        kind: opensteerReverseChannelKindSchema,
-        recordKind: networkRecordKindSchema,
-        method: stringSchema({ minLength: 1 }),
-        url: stringSchema({ minLength: 1 }),
-        subprotocol: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerChannelDescriptor",
-        required: ["kind", "recordKind", "url"]
-      }
-    );
-    opensteerReverseOperationWorkflowStepSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        kind: enumSchema(["operation"]),
-        label: stringSchema({ minLength: 1 }),
-        operation: stringSchema({ minLength: 1 }),
-        input: opensteerValueTemplateSchema,
-        bindAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseOperationWorkflowStep",
-        required: ["id", "kind", "label", "operation", "input"]
-      }
-    );
-    opensteerReverseAwaitRecordWorkflowStepSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        kind: enumSchema(["await-record"]),
-        label: stringSchema({ minLength: 1 }),
-        channel: opensteerChannelDescriptorSchema,
-        recordId: stringSchema({ minLength: 1 }),
-        match: objectSchema(
-          {
-            recordId: stringSchema({ minLength: 1 }),
-            host: stringSchema({ minLength: 1 }),
-            path: stringSchema({ minLength: 1 }),
-            method: stringSchema({ minLength: 1 }),
-            channel: opensteerReverseChannelKindSchema,
-            status: integerSchema({ minimum: 0 }),
-            text: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerReverseAwaitRecordMatch"
-          }
-        ),
-        validationRuleIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        timeoutMs: integerSchema({ minimum: 0 }),
-        bindAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseAwaitRecordWorkflowStep",
-        required: ["id", "kind", "label", "channel"]
-      }
-    );
-    opensteerReverseAssertWorkflowStepSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        kind: enumSchema(["assert"]),
-        label: stringSchema({ minLength: 1 }),
-        validationRuleIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        binding: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseAssertWorkflowStep",
-        required: ["id", "kind", "label", "validationRuleIds"]
-      }
-    );
-    opensteerReverseWorkflowStepSchema = oneOfSchema(
-      [
-        opensteerReverseOperationWorkflowStepSchema,
-        opensteerReverseAwaitRecordWorkflowStepSchema,
-        opensteerReverseAssertWorkflowStepSchema
-      ],
-      {
-        title: "OpensteerReverseWorkflowStep"
-      }
-    );
-    opensteerReversePackageRequirementsSchema = objectSchema(
-      {
-        requiresBrowser: { type: "boolean" },
-        requiresLiveState: { type: "boolean" },
-        manualCalibration: enumSchema(["not-needed", "recommended", "required"]),
-        stateSources: arraySchema(opensteerStateSourceKindSchema, { uniqueItems: true })
-      },
-      {
-        title: "OpensteerReversePackageRequirements",
-        required: ["requiresBrowser", "requiresLiveState", "manualCalibration", "stateSources"]
-      }
-    );
-    opensteerReverseAdvisoryTemplateSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        label: stringSchema({ minLength: 1 }),
-        channel: opensteerReverseChannelKindSchema,
-        execution: enumSchema(["transport", "page-observation"]),
-        stateSource: opensteerStateSourceKindSchema,
-        observationId: stringSchema({ minLength: 1 }),
-        transport: transportKindSchema,
-        guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        resolverIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        requiresBrowser: { type: "boolean" },
-        requiresLiveState: { type: "boolean" },
-        viability: enumSchema(["ready", "draft", "unsupported"]),
-        notes: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseAdvisoryTemplate",
-        required: [
-          "id",
-          "label",
-          "channel",
-          "execution",
-          "stateSource",
-          "guardIds",
-          "resolverIds",
-          "requiresBrowser",
-          "requiresLiveState",
-          "viability"
-        ]
-      }
-    );
-    opensteerReverseGuardRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        kind: enumSchema(["interaction", "state", "script", "manual"]),
-        label: stringSchema({ minLength: 1 }),
-        status: enumSchema(["required", "satisfied", "unresolved"]),
-        interactionTraceId: stringSchema({ minLength: 1 }),
-        notes: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseGuardRecord",
-        required: ["id", "kind", "label", "status"]
-      }
-    );
-    opensteerReverseObservationRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        capturedAt: integerSchema({ minimum: 0 }),
-        pageRef: pageRefSchema,
-        url: stringSchema({ minLength: 1 }),
-        stateSource: opensteerStateSourceKindSchema,
-        networkRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        scriptArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        interactionTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        stateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        notes: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseObservationRecord",
-        required: [
-          "id",
-          "capturedAt",
-          "stateSource",
-          "networkRecordIds",
-          "scriptArtifactIds",
-          "interactionTraceIds",
-          "stateSnapshotIds"
-        ]
-      }
-    );
-    opensteerReverseObservedRecordSchema = objectSchema(
-      {
-        recordId: stringSchema({ minLength: 1 }),
-        observationId: stringSchema({ minLength: 1 }),
-        clusterId: stringSchema({ minLength: 1 }),
-        observedAt: integerSchema({ minimum: 0 }),
-        channel: opensteerChannelDescriptorSchema,
-        bodyCodec: opensteerBodyCodecDescriptorSchema,
-        resourceType: stringSchema({ minLength: 1 }),
-        status: integerSchema({ minimum: 0 }),
-        matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        relationKinds: arraySchema(opensteerObservationClusterRelationshipKindSchema, {
-          uniqueItems: true
-        })
-      },
-      {
-        title: "OpensteerReverseObservedRecord",
-        required: [
-          "recordId",
-          "observationId",
-          "clusterId",
-          "channel",
-          "bodyCodec",
-          "matchedTargetHints",
-          "relationKinds"
-        ]
-      }
-    );
-    opensteerReverseCandidateRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        observationId: stringSchema({ minLength: 1 }),
-        clusterId: stringSchema({ minLength: 1 }),
-        recordId: stringSchema({ minLength: 1 }),
-        channel: opensteerChannelDescriptorSchema,
-        bodyCodec: opensteerBodyCodecDescriptorSchema,
-        boundary: opensteerReverseCandidateBoundarySchema,
-        summary: stringSchema({ minLength: 1 }),
-        matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        advisoryTags: arraySchema(opensteerReverseAdvisoryTagSchema, { uniqueItems: true }),
-        constraints: arraySchema(opensteerReverseConstraintKindSchema, { uniqueItems: true }),
-        signals: opensteerReverseAdvisorySignalsSchema,
-        inputs: arraySchema(opensteerRequestInputDescriptorSchema),
-        resolvers: arraySchema(opensteerExecutableResolverSchema),
-        guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        scriptArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        advisoryTemplates: arraySchema(opensteerReverseAdvisoryTemplateSchema)
-      },
-      {
-        title: "OpensteerReverseCandidateRecord",
-        required: [
-          "id",
-          "observationId",
-          "clusterId",
-          "recordId",
-          "channel",
-          "bodyCodec",
-          "boundary",
-          "summary",
-          "matchedTargetHints",
-          "advisoryTags",
-          "constraints",
-          "signals",
-          "inputs",
-          "resolvers",
-          "guardIds",
-          "scriptArtifactIds",
-          "advisoryTemplates"
-        ]
-      }
-    );
-    opensteerReverseReplayValidationSchema = objectSchema(
-      {
-        statusMatches: { type: "boolean" },
-        structureMatches: { type: "boolean" },
-        opened: { type: "boolean" },
-        firstChunkObserved: { type: "boolean" },
-        firstChunkMatches: { type: "boolean" },
-        messageObserved: { type: "boolean" },
-        messageCount: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerReverseReplayValidation"
-      }
-    );
-    opensteerReverseReplayRunRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        createdAt: integerSchema({ minimum: 0 }),
-        candidateId: stringSchema({ minLength: 1 }),
-        templateId: stringSchema({ minLength: 1 }),
-        packageId: stringSchema({ minLength: 1 }),
-        success: { type: "boolean" },
-        channel: opensteerReverseChannelKindSchema,
-        kind: opensteerReversePackageKindSchema,
-        readiness: opensteerReversePackageReadinessSchema,
-        transport: transportKindSchema,
-        stateSource: opensteerStateSourceKindSchema,
-        executedStepIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        failedStepId: stringSchema({ minLength: 1 }),
-        bindings: recordSchema({}, { title: "OpensteerReverseReplayRunBindings" }),
-        recordId: stringSchema({ minLength: 1 }),
-        status: integerSchema({ minimum: 0 }),
-        validation: opensteerReverseReplayValidationSchema,
-        error: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseReplayRunRecord",
-        required: [
-          "id",
-          "createdAt",
-          "packageId",
-          "success",
-          "kind",
-          "readiness",
-          "executedStepIds",
-          "validation"
-        ]
-      }
-    );
-    opensteerReverseExperimentRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        createdAt: integerSchema({ minimum: 0 }),
-        candidateId: stringSchema({ minLength: 1 }),
-        templateId: stringSchema({ minLength: 1 }),
-        kind: enumSchema(["replay-attempt", "field-variation"]),
-        hypothesis: stringSchema({ minLength: 1 }),
-        success: { type: "boolean" },
-        status: integerSchema({ minimum: 0 }),
-        notes: stringSchema({ minLength: 1 }),
-        validation: opensteerReverseReplayValidationSchema
-      },
-      {
-        title: "OpensteerReverseExperimentRecord",
-        required: ["id", "createdAt", "kind", "hypothesis", "success"]
-      }
-    );
-    opensteerReverseRequirementSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        kind: opensteerReverseRequirementKindSchema,
-        status: opensteerReverseRequirementStatusSchema,
-        label: stringSchema({ minLength: 1 }),
-        description: stringSchema({ minLength: 1 }),
-        blocking: { type: "boolean" },
-        resolverId: stringSchema({ minLength: 1 }),
-        guardId: stringSchema({ minLength: 1 }),
-        stepId: stringSchema({ minLength: 1 }),
-        inputNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        traceId: stringSchema({ minLength: 1 }),
-        artifactId: stringSchema({ minLength: 1 }),
-        recordId: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseRequirement",
-        required: ["id", "kind", "status", "label", "blocking"]
-      }
-    );
-    opensteerReverseSuggestedEditSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        kind: opensteerReverseSuggestedEditKindSchema,
-        label: stringSchema({ minLength: 1 }),
-        description: stringSchema({ minLength: 1 }),
-        resolverId: stringSchema({ minLength: 1 }),
-        guardId: stringSchema({ minLength: 1 }),
-        stepId: stringSchema({ minLength: 1 }),
-        traceId: stringSchema({ minLength: 1 }),
-        artifactId: stringSchema({ minLength: 1 }),
-        recordId: stringSchema({ minLength: 1 }),
-        payload: jsonValueSchema2
-      },
-      {
-        title: "OpensteerReverseSuggestedEdit",
-        required: ["id", "kind", "label"]
-      }
-    );
-    opensteerReverseExportRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        createdAt: integerSchema({ minimum: 0 }),
-        candidateId: stringSchema({ minLength: 1 }),
-        templateId: stringSchema({ minLength: 1 }),
-        packageId: stringSchema({ minLength: 1 }),
-        kind: opensteerReversePackageKindSchema,
-        readiness: opensteerReversePackageReadinessSchema,
-        requestPlanId: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseExportRecord",
-        required: ["id", "createdAt", "packageId", "kind", "readiness"]
-      }
-    );
-    opensteerReverseCasePayloadSchema = objectSchema(
-      {
-        objective: stringSchema({ minLength: 1 }),
-        notes: stringSchema({ minLength: 1 }),
-        status: opensteerReverseCaseStatusSchema,
-        stateSource: opensteerStateSourceKindSchema,
-        observations: arraySchema(opensteerReverseObservationRecordSchema),
-        observationClusters: arraySchema(opensteerObservationClusterSchema),
-        observedRecords: arraySchema(opensteerReverseObservedRecordSchema),
-        candidates: arraySchema(opensteerReverseCandidateRecordSchema),
-        guards: arraySchema(opensteerReverseGuardRecordSchema),
-        stateSnapshots: arraySchema(opensteerStateSnapshotSchema),
-        stateDeltas: arraySchema(opensteerStateDeltaSchema),
-        experiments: arraySchema(opensteerReverseExperimentRecordSchema),
-        replayRuns: arraySchema(opensteerReverseReplayRunRecordSchema),
-        exports: arraySchema(opensteerReverseExportRecordSchema)
-      },
-      {
-        title: "OpensteerReverseCasePayload",
-        required: [
-          "objective",
-          "status",
-          "stateSource",
-          "observations",
-          "observationClusters",
-          "observedRecords",
-          "candidates",
-          "guards",
-          "stateSnapshots",
-          "stateDeltas",
-          "experiments",
-          "replayRuns",
-          "exports"
-        ]
-      }
-    );
-    objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 }),
-        createdAt: integerSchema({ minimum: 0 }),
-        updatedAt: integerSchema({ minimum: 0 }),
-        contentHash: stringSchema({ minLength: 1 }),
-        tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        provenance: opensteerRegistryProvenanceSchema,
-        payload: opensteerReverseCasePayloadSchema
-      },
-      {
-        title: "OpensteerReverseCaseRecord",
-        required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-      }
-    );
-    opensteerReversePackagePayloadSchema = objectSchema(
-      {
-        kind: opensteerReversePackageKindSchema,
-        readiness: opensteerReversePackageReadinessSchema,
-        caseId: stringSchema({ minLength: 1 }),
-        objective: stringSchema({ minLength: 1 }),
-        source: objectSchema(
-          {
-            kind: enumSchema(["record", "candidate"]),
-            id: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerReversePackageSource",
-            required: ["kind", "id"]
-          }
-        ),
-        sourceRecordId: stringSchema({ minLength: 1 }),
-        candidateId: stringSchema({ minLength: 1 }),
-        candidate: opensteerReverseCandidateRecordSchema,
-        templateId: stringSchema({ minLength: 1 }),
-        template: opensteerReverseAdvisoryTemplateSchema,
-        channel: opensteerChannelDescriptorSchema,
-        stateSource: opensteerStateSourceKindSchema,
-        observationId: stringSchema({ minLength: 1 }),
-        transport: transportKindSchema,
-        guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        workflow: arraySchema(opensteerReverseWorkflowStepSchema),
-        resolvers: arraySchema(opensteerExecutableResolverSchema),
-        validators: arraySchema(opensteerValidationRuleSchema),
-        stateSnapshots: arraySchema(opensteerStateSnapshotSchema),
-        requirements: opensteerReversePackageRequirementsSchema,
-        requestPlanId: stringSchema({ minLength: 1 }),
-        unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-        suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-        attachedTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        attachedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        attachedRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        notes: stringSchema({ minLength: 1 }),
-        parentPackageId: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackagePayload",
-        required: [
-          "kind",
-          "readiness",
-          "caseId",
-          "objective",
-          "source",
-          "sourceRecordId",
-          "guardIds",
-          "workflow",
-          "resolvers",
-          "validators",
-          "stateSnapshots",
-          "requirements",
-          "unresolvedRequirements",
-          "suggestedEdits",
-          "attachedTraceIds",
-          "attachedArtifactIds",
-          "attachedRecordIds"
-        ]
-      }
-    );
-    opensteerReversePackageRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 }),
-        createdAt: integerSchema({ minimum: 0 }),
-        updatedAt: integerSchema({ minimum: 0 }),
-        contentHash: stringSchema({ minLength: 1 }),
-        tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        provenance: opensteerRegistryProvenanceSchema,
-        payload: opensteerReversePackagePayloadSchema
-      },
-      {
-        title: "OpensteerReversePackageRecord",
-        required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-      }
-    );
-    opensteerReverseCandidateReportItemSchema = objectSchema(
-      {
-        candidateId: stringSchema({ minLength: 1 }),
-        clusterId: stringSchema({ minLength: 1 }),
-        advisoryRank: numberSchema(),
-        bodyCodec: opensteerBodyCodecDescriptorSchema,
-        summary: stringSchema({ minLength: 1 }),
-        advisoryTags: arraySchema(opensteerReverseAdvisoryTagSchema, { uniqueItems: true }),
-        constraints: arraySchema(opensteerReverseConstraintKindSchema, { uniqueItems: true }),
-        signals: opensteerReverseAdvisorySignalsSchema,
-        reasons: arraySchema(stringSchema({ minLength: 1 }))
-      },
-      {
-        title: "OpensteerReverseCandidateAdvisoryItem",
-        required: [
-          "candidateId",
-          "clusterId",
-          "advisoryRank",
-          "bodyCodec",
-          "summary",
-          "advisoryTags",
-          "constraints",
-          "signals",
-          "reasons"
-        ]
-      }
-    );
-    opensteerReverseDiscoverySummaryCountsSchema = objectSchema(
-      {
-        hosts: recordSchema(integerSchema({ minimum: 0 }), { title: "OpensteerReverseSummaryHosts" }),
-        channels: recordSchema(integerSchema({ minimum: 0 }), {
-          title: "OpensteerReverseSummaryChannels"
-        }),
-        resourceTypes: recordSchema(integerSchema({ minimum: 0 }), {
-          title: "OpensteerReverseSummaryResourceTypes"
-        }),
-        advisoryTags: recordSchema(integerSchema({ minimum: 0 }), {
-          title: "OpensteerReverseSummaryAdvisoryTags"
-        }),
-        constraints: recordSchema(integerSchema({ minimum: 0 }), {
-          title: "OpensteerReverseSummaryConstraints"
-        }),
-        relationKinds: recordSchema(integerSchema({ minimum: 0 }), {
-          title: "OpensteerReverseSummaryRelationKinds"
-        })
-      },
-      {
-        title: "OpensteerReverseDiscoverySummaryCounts",
-        required: [
-          "hosts",
-          "channels",
-          "resourceTypes",
-          "advisoryTags",
-          "constraints",
-          "relationKinds"
-        ]
-      }
-    );
-    opensteerReverseReportPayloadSchema = objectSchema(
-      {
-        kind: opensteerReverseReportKindSchema,
-        caseId: stringSchema({ minLength: 1 }),
-        objective: stringSchema({ minLength: 1 }),
-        packageId: stringSchema({ minLength: 1 }),
-        packageKind: opensteerReversePackageKindSchema,
-        packageReadiness: opensteerReversePackageReadinessSchema,
-        observations: arraySchema(opensteerReverseObservationRecordSchema),
-        observationClusters: arraySchema(opensteerObservationClusterSchema),
-        observedRecords: arraySchema(opensteerReverseObservedRecordSchema),
-        guards: arraySchema(opensteerReverseGuardRecordSchema),
-        stateDeltas: arraySchema(opensteerStateDeltaSchema),
-        summaryCounts: opensteerReverseDiscoverySummaryCountsSchema,
-        candidateAdvisories: arraySchema(opensteerReverseCandidateReportItemSchema),
-        query: objectSchema(
-          {
-            view: opensteerReverseQueryViewSchema,
-            filters: objectSchema(
-              {
-                recordId: stringSchema({ minLength: 1 }),
-                clusterId: stringSchema({ minLength: 1 }),
-                candidateId: stringSchema({ minLength: 1 }),
-                host: stringSchema({ minLength: 1 }),
-                path: stringSchema({ minLength: 1 }),
-                method: stringSchema({ minLength: 1 }),
-                status: stringSchema({ minLength: 1 }),
-                resourceType: stringSchema({ minLength: 1 }),
-                channel: opensteerReverseChannelKindSchema,
-                boundary: opensteerReverseCandidateBoundarySchema,
-                advisoryTag: opensteerReverseAdvisoryTagSchema,
-                constraint: opensteerReverseConstraintKindSchema,
-                bodyCodec: opensteerBodyCodecKindSchema,
-                relationKind: opensteerObservationClusterRelationshipKindSchema,
-                hasGuards: { type: "boolean" },
-                hasResolvers: { type: "boolean" },
-                artifactId: stringSchema({ minLength: 1 }),
-                stateSnapshotId: stringSchema({ minLength: 1 }),
-                traceId: stringSchema({ minLength: 1 }),
-                evidenceRef: stringSchema({ minLength: 1 }),
-                text: stringSchema({ minLength: 1 })
-              },
-              {
-                title: "OpensteerReverseReportQueryFilters"
-              }
-            ),
-            sort: objectSchema(
-              {
-                preset: opensteerReverseSortPresetSchema,
-                keys: arraySchema(
-                  objectSchema(
-                    {
-                      key: opensteerReverseSortKeySchema,
-                      direction: opensteerReverseSortDirectionSchema
-                    },
-                    {
-                      title: "OpensteerReverseReportQuerySortTerm",
-                      required: ["key"]
-                    }
-                  ),
-                  { minItems: 1 }
-                )
-              },
-              {
-                title: "OpensteerReverseReportQuerySort"
-              }
-            ),
-            limit: integerSchema({ minimum: 1 }),
-            totalCount: integerSchema({ minimum: 0 }),
-            nextCursor: stringSchema({ minLength: 1 }),
-            resultIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-          },
-          {
-            title: "OpensteerReverseQuerySnapshot",
-            required: ["view", "sort", "limit", "totalCount", "resultIds"]
-          }
-        ),
-        experiments: arraySchema(opensteerReverseExperimentRecordSchema),
-        replayRuns: arraySchema(opensteerReverseReplayRunRecordSchema),
-        unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-        suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-        linkedNetworkRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        linkedInteractionTraceIds: arraySchema(stringSchema({ minLength: 1 }), {
-          uniqueItems: true
-        }),
-        linkedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        linkedStateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        package: opensteerReversePackageRecordSchema
-      },
-      {
-        title: "OpensteerReverseReportPayload",
-        required: [
-          "kind",
-          "caseId",
-          "objective",
-          "observations",
-          "observationClusters",
-          "observedRecords",
-          "guards",
-          "stateDeltas",
-          "summaryCounts",
-          "candidateAdvisories",
-          "experiments",
-          "replayRuns",
-          "linkedNetworkRecordIds",
-          "linkedInteractionTraceIds",
-          "linkedArtifactIds",
-          "linkedStateSnapshotIds"
-        ]
-      }
-    );
-    opensteerReverseReportRecordSchema = objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 }),
-        createdAt: integerSchema({ minimum: 0 }),
-        updatedAt: integerSchema({ minimum: 0 }),
-        contentHash: stringSchema({ minLength: 1 }),
-        tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        provenance: opensteerRegistryProvenanceSchema,
-        payload: opensteerReverseReportPayloadSchema
-      },
-      {
-        title: "OpensteerReverseReportRecord",
-        required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-      }
-    );
-    opensteerReverseNetworkFilterSchema = objectSchema(
-      {
-        url: stringSchema({ minLength: 1 }),
-        hostname: stringSchema({ minLength: 1 }),
-        path: stringSchema({ minLength: 1 }),
-        method: stringSchema({ minLength: 1 }),
-        resourceType: stringSchema({ minLength: 1 }),
-        includeBodies: { type: "boolean" }
-      },
-      {
-        title: "OpensteerReverseCaptureNetworkFilter"
-      }
-    );
-    opensteerReverseQueryFiltersSchema = objectSchema(
-      {
-        recordId: stringSchema({ minLength: 1 }),
-        clusterId: stringSchema({ minLength: 1 }),
-        candidateId: stringSchema({ minLength: 1 }),
-        host: stringSchema({ minLength: 1 }),
-        path: stringSchema({ minLength: 1 }),
-        method: stringSchema({ minLength: 1 }),
-        status: stringSchema({ minLength: 1 }),
-        resourceType: stringSchema({ minLength: 1 }),
-        channel: opensteerReverseChannelKindSchema,
-        boundary: opensteerReverseCandidateBoundarySchema,
-        advisoryTag: opensteerReverseAdvisoryTagSchema,
-        constraint: opensteerReverseConstraintKindSchema,
-        bodyCodec: opensteerBodyCodecKindSchema,
-        relationKind: opensteerObservationClusterRelationshipKindSchema,
-        hasGuards: { type: "boolean" },
-        hasResolvers: { type: "boolean" },
-        artifactId: stringSchema({ minLength: 1 }),
-        stateSnapshotId: stringSchema({ minLength: 1 }),
-        traceId: stringSchema({ minLength: 1 }),
-        evidenceRef: stringSchema({ minLength: 1 }),
-        text: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseQueryFilters"
-      }
-    );
-    opensteerReverseQuerySortSchema = objectSchema(
-      {
-        preset: opensteerReverseSortPresetSchema,
-        keys: arraySchema(
-          objectSchema(
-            {
-              key: opensteerReverseSortKeySchema,
-              direction: opensteerReverseSortDirectionSchema
-            },
-            {
-              title: "OpensteerReverseSortTerm",
-              required: ["key"]
-            }
-          ),
-          { minItems: 1 }
-        )
-      },
-      {
-        title: "OpensteerReverseQuerySort"
-      }
-    );
-    opensteerReverseQuerySnapshotSchema = objectSchema(
-      {
-        view: opensteerReverseQueryViewSchema,
-        filters: opensteerReverseQueryFiltersSchema,
-        sort: opensteerReverseQuerySortSchema,
-        limit: integerSchema({ minimum: 1, maximum: 200 }),
-        totalCount: integerSchema({ minimum: 0 }),
-        nextCursor: stringSchema({ minLength: 1 }),
-        resultIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-      },
-      {
-        title: "OpensteerReverseQuerySnapshot",
-        required: ["view", "sort", "limit", "totalCount", "resultIds"]
-      }
-    );
-    opensteerReverseQueryRecordItemSchema = objectSchema(
-      {
-        record: opensteerReverseObservedRecordSchema,
-        candidateIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-      },
-      {
-        title: "OpensteerReverseQueryRecordItem",
-        required: ["record", "candidateIds"]
-      }
-    );
-    opensteerReverseQueryClusterItemSchema = objectSchema(
-      {
-        cluster: opensteerObservationClusterSchema,
-        candidateIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-      },
-      {
-        title: "OpensteerReverseQueryClusterItem",
-        required: ["cluster", "candidateIds"]
-      }
-    );
-    opensteerReverseQueryCandidateItemSchema = objectSchema(
-      {
-        candidate: opensteerReverseCandidateRecordSchema,
-        reasons: arraySchema(stringSchema({ minLength: 1 }))
-      },
-      {
-        title: "OpensteerReverseQueryCandidateItem",
-        required: ["candidate", "reasons"]
-      }
-    );
-    objectSchema(
-      {
-        caseId: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        objective: stringSchema({ minLength: 1 }),
-        notes: stringSchema({ minLength: 1 }),
-        tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        pageRef: pageRefSchema,
-        stateSource: opensteerStateSourceKindSchema,
-        network: opensteerReverseNetworkFilterSchema,
-        includeScripts: { type: "boolean" },
-        includeStorage: { type: "boolean" },
-        includeSessionStorage: { type: "boolean" },
-        includeIndexedDb: { type: "boolean" },
-        interactionTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        targetHints: opensteerReverseTargetHintsSchema,
-        captureWindowMs: integerSchema({ minimum: 0 }),
-        manualCalibration: opensteerReverseManualCalibrationModeSchema
-      },
-      {
-        title: "OpensteerReverseDiscoverInput"
-      }
-    );
-    objectSchema(
-      {
-        caseId: stringSchema({ minLength: 1 }),
-        reportId: stringSchema({ minLength: 1 }),
-        summary: objectSchema(
-          {
-            observationIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-            recordCount: integerSchema({ minimum: 0 }),
-            clusterCount: integerSchema({ minimum: 0 }),
-            candidateCount: integerSchema({ minimum: 0 })
-          },
-          {
-            title: "OpensteerReverseDiscoverSummary",
-            required: ["observationIds", "recordCount", "clusterCount", "candidateCount"]
-          }
-        ),
-        index: objectSchema(
-          {
-            views: arraySchema(opensteerReverseQueryViewSchema, { uniqueItems: true }),
-            sortableKeys: arraySchema(opensteerReverseSortKeySchema, { uniqueItems: true }),
-            channels: arraySchema(opensteerReverseChannelKindSchema, { uniqueItems: true }),
-            hosts: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-            relationKinds: arraySchema(opensteerObservationClusterRelationshipKindSchema, {
-              uniqueItems: true
-            })
-          },
-          {
-            title: "OpensteerReverseDiscoverIndex",
-            required: ["views", "sortableKeys", "channels", "hosts", "relationKinds"]
-          }
-        )
-      },
-      {
-        title: "OpensteerReverseDiscoverOutput",
-        required: ["caseId", "reportId", "summary", "index"]
-      }
-    );
-    objectSchema(
-      {
-        caseId: stringSchema({ minLength: 1 }),
-        view: opensteerReverseQueryViewSchema,
-        filters: opensteerReverseQueryFiltersSchema,
-        sort: opensteerReverseQuerySortSchema,
-        limit: integerSchema({ minimum: 1, maximum: 200 }),
-        cursor: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseQueryInput",
-        required: ["caseId"]
-      }
-    );
-    objectSchema(
-      {
-        caseId: stringSchema({ minLength: 1 }),
-        view: opensteerReverseQueryViewSchema,
-        query: opensteerReverseQuerySnapshotSchema,
-        totalCount: integerSchema({ minimum: 0 }),
-        nextCursor: stringSchema({ minLength: 1 }),
-        records: arraySchema(opensteerReverseQueryRecordItemSchema),
-        clusters: arraySchema(opensteerReverseQueryClusterItemSchema),
-        candidates: arraySchema(opensteerReverseQueryCandidateItemSchema)
-      },
-      {
-        title: "OpensteerReverseQueryOutput",
-        required: ["caseId", "view", "query", "totalCount"]
-      }
-    );
-    objectSchema(
-      {
-        caseId: stringSchema({ minLength: 1 }),
-        source: objectSchema(
-          {
-            kind: enumSchema(["record", "candidate"]),
-            id: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerReversePackageCreateSource",
-            required: ["kind", "id"]
-          }
-        ),
-        templateId: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 }),
-        notes: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageCreateInput",
-        required: ["caseId", "source"]
-      }
-    );
-    objectSchema(
-      {
-        package: opensteerReversePackageRecordSchema,
-        report: opensteerReverseReportRecordSchema
-      },
-      {
-        title: "OpensteerReversePackageCreateOutput",
-        required: ["package", "report"]
-      }
-    );
-    objectSchema(
-      {
-        packageId: stringSchema({ minLength: 1 }),
-        pageRef: pageRefSchema
-      },
-      {
-        title: "OpensteerReversePackageRunInput",
-        required: ["packageId"]
-      }
-    );
-    objectSchema(
-      {
-        packageId: stringSchema({ minLength: 1 }),
-        caseId: stringSchema({ minLength: 1 }),
-        source: objectSchema(
-          {
-            kind: enumSchema(["record", "candidate"]),
-            id: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerReversePackageRunSource",
-            required: ["kind", "id"]
-          }
-        ),
-        candidateId: stringSchema({ minLength: 1 }),
-        templateId: stringSchema({ minLength: 1 }),
-        success: { type: "boolean" },
-        kind: opensteerReversePackageKindSchema,
-        readiness: opensteerReversePackageReadinessSchema,
-        channel: opensteerReverseChannelKindSchema,
-        transport: transportKindSchema,
-        stateSource: opensteerStateSourceKindSchema,
-        recordId: stringSchema({ minLength: 1 }),
-        status: integerSchema({ minimum: 0 }),
-        validation: opensteerReverseReplayValidationSchema,
-        executedStepIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        failedStepId: stringSchema({ minLength: 1 }),
-        bindings: recordSchema({}, { title: "OpensteerReversePackageRunBindings" }),
-        replayRunId: stringSchema({ minLength: 1 }),
-        unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-        suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-        error: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageRunOutput",
-        required: [
-          "packageId",
-          "source",
-          "success",
-          "kind",
-          "readiness",
-          "validation",
-          "executedStepIds",
-          "bindings",
-          "unresolvedRequirements",
-          "suggestedEdits"
-        ]
-      }
-    );
-    objectSchema(
-      {
-        packageId: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseExportInput",
-        required: ["packageId"]
-      }
-    );
-    objectSchema(
-      {
-        package: opensteerReversePackageRecordSchema,
-        requestPlan: opensteerRequestPlanRecordSchema
-      },
-      {
-        title: "OpensteerReverseExportOutput",
-        required: ["package"]
-      }
-    );
-    objectSchema(
-      {
-        caseId: stringSchema({ minLength: 1 }),
-        packageId: stringSchema({ minLength: 1 }),
-        reportId: stringSchema({ minLength: 1 }),
-        kind: opensteerReverseReportKindSchema
-      },
-      {
-        title: "OpensteerReverseReportInput"
-      }
-    );
-    objectSchema(
-      {
-        report: opensteerReverseReportRecordSchema
-      },
-      {
-        title: "OpensteerReverseReportOutput",
-        required: ["report"]
-      }
-    );
-    objectSchema(
-      {
-        packageId: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageGetInput",
-        required: ["packageId"]
-      }
-    );
-    objectSchema(
-      {
-        package: opensteerReversePackageRecordSchema
-      },
-      {
-        title: "OpensteerReversePackageGetOutput",
-        required: ["package"]
-      }
-    );
-    objectSchema(
-      {
-        caseId: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        kind: opensteerReversePackageKindSchema,
-        readiness: opensteerReversePackageReadinessSchema
+            title: "SandboxAjaxMockResponse",
+            required: ["status"]
+          }
+        )
       },
       {
-        title: "OpensteerReversePackageListInput"
+        title: "SandboxAjaxRoute",
+        required: ["urlPattern", "mode"]
       }
     );
-    objectSchema(
+    opensteerScriptSandboxInputSchema = objectSchema(
       {
-        packages: arraySchema(opensteerReversePackageRecordSchema)
+        artifactId: stringSchema({ minLength: 1 }),
+        content: stringSchema(),
+        fidelity: sandboxFidelitySchema,
+        ajaxRoutes: arraySchema(sandboxAjaxRouteSchema),
+        cookies: recordSchema(stringSchema(), {
+          title: "SandboxCookies"
+        }),
+        globals: objectSchema(
+          {},
+          {
+            title: "SandboxGlobals",
+            additionalProperties: true
+          }
+        ),
+        timeoutMs: integerSchema({ minimum: 1 }),
+        clockMode: enumSchema(["real", "manual"])
       },
       {
-        title: "OpensteerReversePackageListOutput",
-        required: ["packages"]
+        title: "OpensteerScriptSandboxInput"
       }
     );
-    objectSchema(
+    sandboxCapturedAjaxCallSchema = objectSchema(
       {
-        packageId: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 }),
-        notes: stringSchema({ minLength: 1 }),
-        workflow: arraySchema(opensteerReverseWorkflowStepSchema),
-        resolvers: arraySchema(opensteerExecutableResolverSchema),
-        validators: arraySchema(opensteerValidationRuleSchema),
-        attachedTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        attachedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        attachedRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        stateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
+        method: stringSchema({ minLength: 1 }),
+        url: stringSchema({ minLength: 1 }),
+        headers: recordSchema(stringSchema(), {
+          title: "SandboxCapturedAjaxHeaders"
+        }),
+        body: stringSchema(),
+        timestamp: integerSchema({ minimum: 0 })
       },
       {
-        title: "OpensteerReversePackagePatchInput",
-        required: ["packageId"]
+        title: "SandboxCapturedAjaxCall",
+        required: ["method", "url", "headers", "timestamp"]
       }
     );
-    objectSchema(
+    opensteerScriptSandboxOutputSchema = objectSchema(
       {
-        package: opensteerReversePackageRecordSchema,
-        report: opensteerReverseReportRecordSchema
+        result: oneOfSchema(
+          [
+            objectSchema({}, { additionalProperties: true }),
+            arraySchema({}),
+            stringSchema(),
+            { type: "number" },
+            enumSchema([true, false, null])
+          ],
+          {
+            title: "SandboxResult"
+          }
+        ),
+        capturedAjax: arraySchema(sandboxCapturedAjaxCallSchema),
+        errors: arraySchema(stringSchema({ minLength: 1 })),
+        durationMs: integerSchema({ minimum: 0 })
       },
       {
-        title: "OpensteerReversePackagePatchOutput",
-        required: ["package", "report"]
+        title: "OpensteerScriptSandboxOutput",
+        required: ["capturedAjax", "errors", "durationMs"]
       }
     );
   }
@@ -8301,7 +6371,7 @@ var init_interaction = __esm({
     init_json2();
     init_identity2();
     init_requests();
-    init_reverse();
+    init_state();
     opensteerInteractionEventRecordSchema = objectSchema(
       {
         type: stringSchema({ minLength: 1 }),
@@ -8603,7 +6673,7 @@ function assertValidSemanticOperationInput(name, input) {
     }
   );
 }
-var opensteerComputerAnnotationNames, opensteerExposedSemanticOperationNames, opensteerPackageRunnableSemanticOperationNames, snapshotModeSchema, viewportSchema, opensteerBrowserLaunchOptionsSchema, attachBrowserOptionsSchema, opensteerBrowserOptionsSchema, opensteerBrowserContextOptionsSchema, targetByElementSchema2, targetByPersistSchema2, targetBySelectorSchema2, opensteerTargetInputSchema, opensteerResolvedTargetSchema, opensteerActionResultSchema, opensteerSnapshotCounterSchema, opensteerSessionStateSchema, opensteerOpenInputSchema, opensteerPageListInputSchema, opensteerPageListOutputSchema, opensteerPageNewInputSchema, opensteerPageActivateInputSchema, opensteerPageCloseInputSchema, opensteerPageCloseOutputSchema, opensteerPageGotoInputSchema, opensteerPageEvaluateInputSchema, opensteerPageEvaluateOutputSchema, opensteerAddInitScriptInputSchema, opensteerAddInitScriptOutputSchema, opensteerCapturedScriptSchema, opensteerCaptureScriptsInputSchema, opensteerCaptureScriptsOutputSchema, opensteerPageSnapshotInputSchema, opensteerPageSnapshotOutputSchema, opensteerComputerMouseButtonSchema, opensteerComputerKeyModifierSchema, opensteerDomClickInputSchema, opensteerDomHoverInputSchema, opensteerDomInputInputSchema, opensteerDomScrollInputSchema, opensteerExtractSchemaSchema, opensteerDomExtractInputSchema, jsonValueSchema3, opensteerDomExtractOutputSchema, opensteerSessionCloseInputSchema, opensteerSessionCloseOutputSchema, opensteerComputerAnnotationSchema, opensteerComputerClickActionSchema, opensteerComputerMoveActionSchema, opensteerComputerScrollActionSchema, opensteerComputerTypeActionSchema, opensteerComputerKeyActionSchema, opensteerComputerDragActionSchema, opensteerComputerScreenshotActionSchema, opensteerComputerWaitActionSchema, opensteerComputerActionSchema, opensteerComputerScreenshotOptionsSchema, opensteerComputerExecuteInputSchema, opensteerComputerTracePointSchema, opensteerComputerTraceEnrichmentSchema, opensteerComputerExecuteTimingSchema, opensteerComputerDisplayScaleSchema, opensteerComputerExecuteOutputSchema, opensteerSemanticOperationSpecificationsBase, exposedSemanticOperationNameSet, opensteerSemanticOperationSpecificationsInternal, opensteerSemanticOperationSpecifications, opensteerSemanticOperationSpecificationMap, semanticRestBasePath, opensteerSemanticRestEndpoints;
+var opensteerComputerAnnotationNames, opensteerExposedSemanticOperationNames, opensteerPackageRunnableSemanticOperationNames, snapshotModeSchema, viewportSchema, opensteerBrowserLaunchOptionsSchema, attachBrowserOptionsSchema, opensteerBrowserOptionsSchema, opensteerBrowserContextOptionsSchema, targetByElementSchema2, targetByPersistSchema2, targetBySelectorSchema2, opensteerTargetInputSchema, opensteerResolvedTargetSchema, opensteerActionResultSchema, opensteerSnapshotCounterSchema, opensteerSessionStateSchema, opensteerOpenInputSchema, opensteerPageListInputSchema, opensteerPageListOutputSchema, opensteerPageNewInputSchema, opensteerPageActivateInputSchema, opensteerPageCloseInputSchema, opensteerPageCloseOutputSchema, opensteerPageGotoInputSchema, opensteerPageEvaluateInputSchema, opensteerPageEvaluateOutputSchema, opensteerAddInitScriptInputSchema, opensteerAddInitScriptOutputSchema, opensteerCapturedScriptSchema, opensteerCaptureScriptsInputSchema, opensteerCaptureScriptsOutputSchema, opensteerPageSnapshotInputSchema, opensteerPageSnapshotOutputSchema, opensteerComputerMouseButtonSchema, opensteerComputerKeyModifierSchema, opensteerDomClickInputSchema, opensteerDomHoverInputSchema, opensteerDomInputInputSchema, opensteerDomScrollInputSchema, opensteerExtractSchemaSchema, opensteerDomExtractInputSchema, jsonValueSchema2, opensteerDomExtractOutputSchema, opensteerSessionCloseInputSchema, opensteerSessionCloseOutputSchema, opensteerComputerAnnotationSchema, opensteerComputerClickActionSchema, opensteerComputerMoveActionSchema, opensteerComputerScrollActionSchema, opensteerComputerTypeActionSchema, opensteerComputerKeyActionSchema, opensteerComputerDragActionSchema, opensteerComputerScreenshotActionSchema, opensteerComputerWaitActionSchema, opensteerComputerActionSchema, opensteerComputerScreenshotOptionsSchema, opensteerComputerExecuteInputSchema, opensteerComputerTracePointSchema, opensteerComputerTraceEnrichmentSchema, opensteerComputerExecuteTimingSchema, opensteerComputerDisplayScaleSchema, opensteerComputerExecuteOutputSchema, opensteerSemanticOperationSpecificationsBase, exposedSemanticOperationNameSet, opensteerSemanticOperationSpecificationsInternal, opensteerSemanticOperationSpecifications, opensteerSemanticOperationSpecificationMap, semanticRestBasePath, opensteerSemanticRestEndpoints;
 var init_semantic = __esm({
   "../protocol/src/semantic.ts"() {
     init_json2();
@@ -9190,12 +7260,12 @@ var init_semantic = __esm({
       ),
       anyOf: [defineSchema({ required: ["persist"] }), defineSchema({ required: ["schema"] })]
     });
-    jsonValueSchema3 = recordSchema({}, { title: "JsonValueRecord" });
+    jsonValueSchema2 = recordSchema({}, { title: "JsonValueRecord" });
     opensteerDomExtractOutputSchema = objectSchema(
       {
         data: oneOfSchema(
           [
-            jsonValueSchema3,
+            jsonValueSchema2,
             arraySchema({}),
             stringSchema(),
             numberSchema(),
@@ -9580,7 +7650,7 @@ var init_semantic = __esm({
       }),
       defineSemanticOperationSpec({
         name: "artifact.read",
-        description: "Read a persisted artifact by ID so agents can inspect captured scripts, storage, cookies, or snapshots linked from reverse packages and reports.",
+        description: "Read a persisted artifact by ID so agents can inspect captured scripts, storage, cookies, or snapshots linked from recorded workflows.",
         inputSchema: opensteerArtifactReadInputSchema,
         outputSchema: opensteerArtifactReadOutputSchema,
         requiredCapabilities: []
@@ -9823,6 +7893,7 @@ var init_src2 = __esm({
     init_network2();
     init_requests();
     init_storage2();
+    init_state();
     init_snapshots2();
     init_capabilities2();
     init_cloud();
@@ -9840,7 +7911,6 @@ var init_src2 = __esm({
     init_rest();
     init_mcp();
     init_scripts();
-    init_reverse();
     init_interaction();
     init_semantic();
     init_computer_use_bridge();
@@ -9894,25 +7964,10 @@ function createDescriptorRegistry(rootPath) {
 function createRequestPlanRegistry(rootPath) {
   return new FilesystemRequestPlanRegistry(rootPath);
 }
-function createAuthRecipeRegistry(rootPath) {
-  return new FilesystemAuthRecipeRegistry(rootPath);
-}
-function createRecipeRegistry(rootPath) {
-  return new FilesystemRecipeRegistry(rootPath);
-}
 function createInteractionTraceRegistry(rootPath) {
   return new FilesystemInteractionTraceRegistry(rootPath);
 }
-function createReverseCaseRegistry(rootPath) {
-  return new FilesystemReverseCaseRegistry(rootPath);
-}
-function createReversePackageRegistry(rootPath) {
-  return new FilesystemReversePackageRegistry(rootPath);
-}
-function createReverseReportRegistry(rootPath) {
-  return new FilesystemReverseReportRegistry(rootPath);
-}
-var FilesystemRegistryStore, FilesystemDescriptorRegistry, FilesystemRequestPlanRegistry, FilesystemAuthRecipeRegistry, FilesystemRecipeRegistry, FilesystemInteractionTraceRegistry, FilesystemReverseCaseRegistry, FilesystemReversePackageRegistry, FilesystemReverseReportRegistry;
+var FilesystemRegistryStore, FilesystemDescriptorRegistry, FilesystemRequestPlanRegistry, FilesystemInteractionTraceRegistry;
 var init_registry = __esm({
   "../runtime-core/src/registry.ts"() {
     init_filesystem();
@@ -10132,76 +8187,6 @@ var init_registry = __esm({
         });
       }
     };
-    FilesystemAuthRecipeRegistry = class extends FilesystemRegistryStore {
-      constructor(rootPath) {
-        super(rootPath, ["registry", "auth-recipes"]);
-      }
-      async write(input) {
-        const id = normalizeNonEmptyString("id", input.id ?? `auth-recipe:${crypto.randomUUID()}`);
-        const key = normalizeNonEmptyString("key", input.key);
-        const version = normalizeNonEmptyString("version", input.version);
-        const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-        const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-        if (updatedAt < createdAt) {
-          throw new RangeError("updatedAt must be greater than or equal to createdAt");
-        }
-        const payload = input.payload;
-        const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-        const provenance = normalizeProvenance2(input.provenance);
-        const record = {
-          id,
-          key,
-          version,
-          createdAt,
-          updatedAt,
-          contentHash,
-          tags: normalizeTags(input.tags),
-          ...provenance === void 0 ? {} : { provenance },
-          payload
-        };
-        return this.writeRecord(record);
-      }
-      async list(input = {}) {
-        const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-        const records = await this.readAllRecords();
-        return key === void 0 ? records : records.filter((record) => record.key === key);
-      }
-    };
-    FilesystemRecipeRegistry = class extends FilesystemRegistryStore {
-      constructor(rootPath) {
-        super(rootPath, ["registry", "recipes"]);
-      }
-      async write(input) {
-        const id = normalizeNonEmptyString("id", input.id ?? `recipe:${crypto.randomUUID()}`);
-        const key = normalizeNonEmptyString("key", input.key);
-        const version = normalizeNonEmptyString("version", input.version);
-        const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-        const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-        if (updatedAt < createdAt) {
-          throw new RangeError("updatedAt must be greater than or equal to createdAt");
-        }
-        const payload = input.payload;
-        const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-        const provenance = normalizeProvenance2(input.provenance);
-        const record = {
-          id,
-          key,
-          version,
-          createdAt,
-          updatedAt,
-          contentHash,
-          tags: normalizeTags(input.tags),
-          ...provenance === void 0 ? {} : { provenance },
-          payload
-        };
-        return this.writeRecord(record);
-      }
-      async list(input = {}) {
-        const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-        const records = await this.readAllRecords();
-        return key === void 0 ? records : records.filter((record) => record.key === key);
-      }
-    };
     FilesystemInteractionTraceRegistry = class extends FilesystemRegistryStore {
       constructor(rootPath) {
         super(rootPath, ["registry", "interaction-traces"]);
@@ -10237,139 +8222,6 @@ var init_registry = __esm({
         return key === void 0 ? records : records.filter((record) => record.key === key);
       }
     };
-    FilesystemReverseCaseRegistry = class extends FilesystemRegistryStore {
-      constructor(rootPath) {
-        super(rootPath, ["registry", "reverse-cases"]);
-      }
-      async write(input) {
-        const id = normalizeNonEmptyString("id", input.id ?? `reverse-case:${crypto.randomUUID()}`);
-        const key = normalizeNonEmptyString("key", input.key);
-        const version = normalizeNonEmptyString("version", input.version);
-        const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-        const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-        if (updatedAt < createdAt) {
-          throw new RangeError("updatedAt must be greater than or equal to createdAt");
-        }
-        const payload = input.payload;
-        const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-        const provenance = normalizeProvenance2(input.provenance);
-        const record = {
-          id,
-          key,
-          version,
-          createdAt,
-          updatedAt,
-          contentHash,
-          tags: normalizeTags(input.tags),
-          ...provenance === void 0 ? {} : { provenance },
-          payload
-        };
-        return this.writeRecord(record);
-      }
-      async list(input = {}) {
-        const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-        const records = await this.readAllRecords();
-        return key === void 0 ? records : records.filter((record) => record.key === key);
-      }
-      async update(input) {
-        const id = normalizeNonEmptyString("id", input.id);
-        return withFilesystemLock(this.writeLockPath(), async () => {
-          const existing = await this.getById(id);
-          if (existing === void 0) {
-            throw new Error(`registry record ${id} was not found`);
-          }
-          const nextUpdatedAt = normalizeTimestamp(
-            "updatedAt",
-            input.updatedAt ?? Math.max(Date.now(), existing.updatedAt)
-          );
-          if (nextUpdatedAt < existing.createdAt) {
-            throw new RangeError("updatedAt must be greater than or equal to createdAt");
-          }
-          const nextPayload = input.payload;
-          const nextProvenance = normalizeProvenance2(input.provenance ?? existing.provenance);
-          const nextRecord = {
-            ...existing,
-            updatedAt: nextUpdatedAt,
-            contentHash: sha256Hex(Buffer.from(canonicalJsonString(nextPayload), "utf8")),
-            tags: normalizeTags(input.tags ?? existing.tags),
-            ...nextProvenance === void 0 ? {} : { provenance: nextProvenance },
-            payload: nextPayload
-          };
-          await writeJsonFileAtomic(this.recordPath(id), nextRecord);
-          return nextRecord;
-        });
-      }
-    };
-    FilesystemReversePackageRegistry = class extends FilesystemRegistryStore {
-      constructor(rootPath) {
-        super(rootPath, ["registry", "reverse-packages"]);
-      }
-      async write(input) {
-        const id = normalizeNonEmptyString("id", input.id ?? `reverse-package:${crypto.randomUUID()}`);
-        const key = normalizeNonEmptyString("key", input.key);
-        const version = normalizeNonEmptyString("version", input.version);
-        const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-        const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-        if (updatedAt < createdAt) {
-          throw new RangeError("updatedAt must be greater than or equal to createdAt");
-        }
-        const payload = input.payload;
-        const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-        const provenance = normalizeProvenance2(input.provenance);
-        const record = {
-          id,
-          key,
-          version,
-          createdAt,
-          updatedAt,
-          contentHash,
-          tags: normalizeTags(input.tags),
-          ...provenance === void 0 ? {} : { provenance },
-          payload
-        };
-        return this.writeRecord(record);
-      }
-      async list(input = {}) {
-        const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-        const records = await this.readAllRecords();
-        return key === void 0 ? records : records.filter((record) => record.key === key);
-      }
-    };
-    FilesystemReverseReportRegistry = class extends FilesystemRegistryStore {
-      constructor(rootPath) {
-        super(rootPath, ["registry", "reverse-reports"]);
-      }
-      async write(input) {
-        const id = normalizeNonEmptyString("id", input.id ?? `reverse-report:${crypto.randomUUID()}`);
-        const key = normalizeNonEmptyString("key", input.key);
-        const version = normalizeNonEmptyString("version", input.version);
-        const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-        const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-        if (updatedAt < createdAt) {
-          throw new RangeError("updatedAt must be greater than or equal to createdAt");
-        }
-        const payload = input.payload;
-        const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-        const provenance = normalizeProvenance2(input.provenance);
-        const record = {
-          id,
-          key,
-          version,
-          createdAt,
-          updatedAt,
-          contentHash,
-          tags: normalizeTags(input.tags),
-          ...provenance === void 0 ? {} : { provenance },
-          payload
-        };
-        return this.writeRecord(record);
-      }
-      async list(input = {}) {
-        const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-        const records = await this.readAllRecords();
-        return key === void 0 ? records : records.filter((record) => record.key === key);
-      }
-    };
   }
 });
 function buildSavedNetworkWhere(input) {
@@ -11837,20 +9689,10 @@ async function createFilesystemOpensteerWorkspace(options) {
   await descriptors.initialize();
   const requestPlans = createRequestPlanRegistry(options.rootPath);
   await requestPlans.initialize();
-  const authRecipes = createAuthRecipeRegistry(options.rootPath);
-  await authRecipes.initialize();
-  const recipes = createRecipeRegistry(options.rootPath);
-  await recipes.initialize();
   const savedNetwork = createSavedNetworkStore(options.rootPath);
   await savedNetwork.initialize();
-  const reverseCases = createReverseCaseRegistry(options.rootPath);
-  await reverseCases.initialize();
   const interactionTraces = createInteractionTraceRegistry(options.rootPath);
   await interactionTraces.initialize();
-  const reversePackages = createReversePackageRegistry(options.rootPath);
-  await reversePackages.initialize();
-  const reverseReports = createReverseReportRegistry(options.rootPath);
-  await reverseReports.initialize();
   const traces = createTraceStore(options.rootPath, artifacts);
   await traces.initialize();
   const observations = createObservationStore(options.rootPath, artifacts);
@@ -11876,13 +9718,8 @@ async function createFilesystemOpensteerWorkspace(options) {
     registry: {
       descriptors,
       requestPlans,
-      authRecipes,
-      recipes,
       savedNetwork,
-      reverseCases,
-      interactionTraces,
-      reversePackages,
-      reverseReports
+      interactionTraces
     },
     lock(task) {
       return withFilesystemLock(lockPath, task);
@@ -14320,7 +12157,7 @@ var init_package = __esm({
   "../runtime-core/package.json"() {
     package_default2 = {
       name: "@opensteer/runtime-core",
-      version: "0.2.1",
+      version: "0.2.2",
       description: "Shared semantic runtime for Opensteer local and cloud execution.",
       license: "MIT",
       type: "module",
@@ -32184,7 +30021,7 @@ var init_opensteer = __esm({
           scroll: (input) => this.scroll(input)
         };
         this.network = {
-          query: (input = {}) => this.queryNetwork(input),
+          query: (input = {}) => this.runtime.queryNetwork(input),
           detail: (recordId, options2) => this.runtime.getNetworkDetail({ recordId, ...options2 })
         };
       }
@@ -32218,9 +30055,6 @@ var init_opensteer = __esm({
         } : input;
         return (await this.runtime.evaluate(normalized)).value;
       }
-      async evaluateJson(input) {
-        return this.evaluate(input);
-      }
       async addInitScript(input) {
         return this.runtime.addInitScript(
           typeof input === "string" ? {
@@ -32257,34 +30091,6 @@ var init_opensteer = __esm({
       async extract(input) {
         return (await this.runtime.extract(input)).data;
       }
-      async queryNetwork(input = {}) {
-        return this.runtime.queryNetwork(input);
-      }
-      async waitForNetwork(input) {
-        const { timeoutMs, pollIntervalMs, ...query } = input;
-        const timeoutAt = Date.now() + (timeoutMs ?? 3e4);
-        const pollInterval = pollIntervalMs ?? 100;
-        const baseline = new Set(
-          (await this.runtime.queryNetwork({ ...query, limit: 200 })).records.map(
-            (record) => record.recordId
-          )
-        );
-        while (true) {
-          const next = (await this.runtime.queryNetwork({ ...query, limit: 200 })).records.find(
-            (record) => !baseline.has(record.recordId)
-          );
-          if (next !== void 0) {
-            return next;
-          }
-          if (Date.now() >= timeoutAt) {
-            throw new Error("waitForNetwork timed out");
-          }
-          await delay5(pollInterval);
-        }
-      }
-      async waitForResponse(input) {
-        return this.waitForNetwork(input);
-      }
       async waitForPage(input = {}) {
         const baseline = new Set((await this.runtime.listPages()).pages.map((page) => page.pageRef));
         const timeoutAt = Date.now() + (input.timeoutMs ?? 3e4);
@@ -32371,7 +30177,7 @@ var init_opensteer = __esm({
 
 // package.json
 var package_default = {
-  version: "0.9.1"};
+  version: "0.9.2"};
 
 // src/cli/bin.ts
 init_browser_manager();