@opensteer/runtime-core 0.2.1 → 0.2.2

package/dist/index.cjs

@@ -41,7 +41,7 @@ var vm__default = /*#__PURE__*/_interopDefault(vm);
 
 // package.json
 var package_default = {
-  version: "0.2.1"};
+  version: "0.2.2"};
 
 // src/version.ts
 var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
@@ -1481,55 +1481,6 @@ arraySchema(headerEntrySchema, {
   title: "OrderedHeaders"
 });
 
-// ../protocol/src/captcha.ts
-var captchaTypeSchema = enumSchema(
-  ["recaptcha-v2", "hcaptcha", "turnstile"],
-  {
-    title: "CaptchaType"
-  }
-);
-var captchaProviderSchema = enumSchema(["2captcha", "capsolver"], {
-  title: "CaptchaProvider"
-});
-var captchaDetectionResultSchema = objectSchema(
-  {
-    type: captchaTypeSchema,
-    siteKey: stringSchema({ minLength: 1 }),
-    pageUrl: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "CaptchaDetectionResult",
-    required: ["type", "siteKey", "pageUrl"]
-  }
-);
-var 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"]
-  }
-);
-var 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 = {};
 var cookieSameSiteSchema = enumSchema(["strict", "lax", "none"], {
@@ -1782,16 +1733,6 @@ var opensteerRequestPlanResponseExpectationSchema = objectSchema(
     required: ["status"]
   }
 );
-var opensteerRecipeRefSchema = objectSchema(
-  {
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerRecipeRef",
-    required: ["key"]
-  }
-);
 var opensteerRequestFailurePolicyHeaderMatchSchema = objectSchema(
   {
     name: stringSchema({ minLength: 1 }),
@@ -1847,46 +1788,9 @@ var opensteerRequestRetryPolicySchema = objectSchema(
     required: ["maxRetries"]
   }
 );
-var opensteerRecipeCachePolicySchema = enumSchema(
-  ["none", "untilFailure"],
-  {
-    title: "OpensteerRecipeCachePolicy"
-  }
-);
-var opensteerRequestPlanRecipeBindingSchema = objectSchema(
-  {
-    recipe: opensteerRecipeRefSchema,
-    cachePolicy: opensteerRecipeCachePolicySchema
-  },
-  {
-    title: "OpensteerRequestPlanRecipeBinding",
-    required: ["recipe"]
-  }
-);
-var opensteerRequestPlanRecoverBindingSchema = objectSchema(
-  {
-    recipe: opensteerRecipeRefSchema,
-    cachePolicy: opensteerRecipeCachePolicySchema,
-    failurePolicy: opensteerRequestFailurePolicySchema
-  },
-  {
-    title: "OpensteerRequestPlanRecoverBinding",
-    required: ["recipe", "failurePolicy"]
-  }
-);
-var opensteerRequestPlanRecipesSchema = objectSchema(
-  {
-    prepare: opensteerRequestPlanRecipeBindingSchema,
-    recover: opensteerRequestPlanRecoverBindingSchema
-  },
-  {
-    title: "OpensteerRequestPlanRecipes"
-  }
-);
 var opensteerRequestPlanAuthSchema = objectSchema(
   {
     strategy: enumSchema(["session-cookie", "bearer-token", "api-key", "custom"]),
-    recipe: opensteerRecipeRefSchema,
     failurePolicy: opensteerRequestFailurePolicySchema,
     description: stringSchema({ minLength: 1 })
   },
@@ -1902,7 +1806,6 @@ var opensteerRequestPlanPayloadSchema = objectSchema(
     parameters: arraySchema(opensteerRequestPlanParameterSchema),
     body: opensteerRequestPlanBodySchema,
     response: opensteerRequestPlanResponseExpectationSchema,
-    recipes: opensteerRequestPlanRecipesSchema,
     retryPolicy: opensteerRequestRetryPolicySchema,
     auth: opensteerRequestPlanAuthSchema
   },
@@ -1993,317 +1896,6 @@ var opensteerRequestBodyInputSchema = oneOfSchema(
     title: "OpensteerRequestBodyInput"
   }
 );
-var opensteerRecipeRetryOverridesSchema = objectSchema(
-  {
-    params: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeParams"
-    }),
-    headers: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeHeaders"
-    }),
-    query: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeQuery"
-    }),
-    body: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeBodyVariables"
-    })
-  },
-  {
-    title: "OpensteerRecipeRetryOverrides"
-  }
-);
-var opensteerRecipeStepResponseCaptureSchema = 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(
-      {
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeBodyTextCapture",
-        required: ["saveAs"]
-      }
-    )
-  },
-  {
-    title: "OpensteerRecipeStepResponseCapture"
-  }
-);
-var opensteerRecipeRequestStepInputSchema = 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" }
-  },
-  {
-    title: "OpensteerRecipeRequestStepInput",
-    required: ["url"]
-  }
-);
-var opensteerRecipeHookRefSchema = objectSchema(
-  {
-    specifier: stringSchema({ minLength: 1 }),
-    export: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerRecipeHookRef",
-    required: ["specifier", "export"]
-  }
-);
-var opensteerRecipeStepSchema = oneOfSchema(
-  [
-    objectSchema(
-      {
-        kind: enumSchema(["goto"]),
-        url: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeGotoStep",
-        required: ["kind", "url"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["reload"])
-      },
-      {
-        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: "OpensteerRecipeStep"
-  }
-);
-var opensteerRecipePayloadSchema = objectSchema(
-  {
-    description: stringSchema({ minLength: 1 }),
-    steps: arraySchema(opensteerRecipeStepSchema, {
-      minItems: 1
-    }),
-    outputs: opensteerRecipeRetryOverridesSchema
-  },
-  {
-    title: "OpensteerRecipePayload",
-    required: ["steps"]
-  }
-);
-var 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
-  },
-  {
-    title: "OpensteerRecipeRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
 var opensteerNetworkQueryInputSchema = objectSchema(
   {
     pageRef: pageRefSchema,
@@ -2702,85 +2294,6 @@ objectSchema(
     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 }),
@@ -2887,17 +2400,7 @@ objectSchema(
       {
         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",
@@ -2936,6 +2439,69 @@ objectSchema(
   }
 );
 
+// ../protocol/src/state.ts
+var 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"]
+  }
+);
+var 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"]
+  }
+);
+var 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 = enumSchema(["png", "jpeg", "webp"], {
   title: "ScreenshotFormat"
@@ -3709,6 +3275,55 @@ var opensteerArtifactReadOutputSchema = objectSchema(
   }
 );
 
+// ../protocol/src/captcha.ts
+var captchaTypeSchema = enumSchema(
+  ["recaptcha-v2", "hcaptcha", "turnstile"],
+  {
+    title: "CaptchaType"
+  }
+);
+var captchaProviderSchema = enumSchema(["2captcha", "capsolver"], {
+  title: "CaptchaProvider"
+});
+var captchaDetectionResultSchema = objectSchema(
+  {
+    type: captchaTypeSchema,
+    siteKey: stringSchema({ minLength: 1 }),
+    pageUrl: stringSchema({ minLength: 1 })
+  },
+  {
+    title: "CaptchaDetectionResult",
+    required: ["type", "siteKey", "pageUrl"]
+  }
+);
+var 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"]
+  }
+);
+var opensteerCaptchaSolveOutputSchema = objectSchema(
+  {
+    captcha: captchaDetectionResultSchema,
+    token: stringSchema({ minLength: 1 }),
+    injected: { type: "boolean" },
+    provider: captchaProviderSchema
+  },
+  {
+    title: "OpensteerCaptchaSolveOutput",
+    required: ["captcha", "token", "injected", "provider"]
+  }
+);
+
 // ../protocol/src/traces.ts
 var traceContextSchema = objectSchema(
   {
@@ -3879,1629 +3494,87 @@ var sandboxAjaxModeSchema = enumSchema(
   }
 );
 var sandboxAjaxRouteSchema = objectSchema(
-  {
-    urlPattern: stringSchema({ minLength: 1 }),
-    mode: sandboxAjaxModeSchema,
-    mockResponse: objectSchema(
-      {
-        status: integerSchema({ minimum: 100, maximum: 599 }),
-        headers: recordSchema(stringSchema(), {
-          title: "SandboxAjaxMockHeaders"
-        }),
-        body: stringSchema()
-      },
-      {
-        title: "SandboxAjaxMockResponse",
-        required: ["status"]
-      }
-    )
-  },
-  {
-    title: "SandboxAjaxRoute",
-    required: ["urlPattern", "mode"]
-  }
-);
-var 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"
-  }
-);
-var 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"]
-  }
-);
-var 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 = enumSchema(
-  ["temporary", "persistent", "attach"],
-  { title: "OpensteerStateSourceKind" }
-);
-var opensteerReverseCaseStatusSchema = enumSchema(
-  ["capturing", "analyzing", "ready", "attention"],
-  { title: "OpensteerReverseCaseStatus" }
-);
-var opensteerReverseChannelKindSchema = enumSchema(
-  ["http", "event-stream", "websocket"],
-  { title: "OpensteerReverseChannelKind" }
-);
-var opensteerReverseManualCalibrationModeSchema = enumSchema(
-  ["allow", "avoid", "require"],
-  { title: "OpensteerReverseManualCalibrationMode" }
-);
-var opensteerReverseCandidateBoundarySchema = enumSchema(
-  ["first-party", "same-site", "third-party"],
-  { title: "OpensteerReverseCandidateBoundary" }
-);
-var opensteerReverseAdvisoryTagSchema = enumSchema(
-  [
-    "data",
-    "facet",
-    "telemetry",
-    "subscription",
-    "navigation",
-    "document",
-    "route-data",
-    "search",
-    "tracking",
-    "unknown"
-  ],
-  { title: "OpensteerReverseAdvisoryTag" }
-);
-var opensteerReverseConstraintKindSchema = enumSchema(
-  [
-    "requires-browser",
-    "requires-cookie",
-    "requires-storage",
-    "requires-script",
-    "requires-guard",
-    "requires-live-state",
-    "opaque-body",
-    "unsupported"
-  ],
-  { title: "OpensteerReverseConstraintKind" }
-);
-var opensteerRequestInputLocationSchema = enumSchema(
-  ["path", "query", "header", "cookie", "body-field"],
-  { title: "OpensteerRequestInputLocation" }
-);
-var opensteerRequestInputRequirednessSchema = enumSchema(
-  ["required", "optional", "unknown"],
-  { title: "OpensteerRequestInputRequiredness" }
-);
-var opensteerRequestInputClassificationSchema = enumSchema(
-  ["managed", "static", "contextual", "volatile"],
-  { title: "OpensteerRequestInputClassification" }
-);
-var opensteerRequestInputSourceSchema = enumSchema(
-  [
-    "literal",
-    "cookie",
-    "storage",
-    "prior-response",
-    "page",
-    "script",
-    "guard-output",
-    "runtime-managed",
-    "unknown"
-  ],
-  { title: "OpensteerRequestInputSource" }
-);
-var opensteerRequestInputMaterializationPolicySchema = enumSchema(
-  ["copy", "omit", "recompute", "resolve"],
-  { title: "OpensteerRequestInputMaterializationPolicy" }
-);
-var opensteerRequestInputExportPolicySchema = enumSchema(
-  ["portable", "browser-bound", "blocked"],
-  { title: "OpensteerRequestInputExportPolicy" }
-);
-var opensteerReverseQueryViewSchema = enumSchema(
-  ["records", "clusters", "candidates"],
-  { title: "OpensteerReverseQueryView" }
-);
-var opensteerReverseSortKeySchema = enumSchema(
-  [
-    "observed-at",
-    "advisory-rank",
-    "target-hint-matches",
-    "response-richness",
-    "portability",
-    "boundary",
-    "success"
-  ],
-  { title: "OpensteerReverseSortKey" }
-);
-var opensteerReverseSortPresetSchema = enumSchema(
-  [
-    "advisory-rank",
-    "observed-at",
-    "portability",
-    "first-party",
-    "hint-match",
-    "response-richness"
-  ],
-  { title: "OpensteerReverseSortPreset" }
-);
-var opensteerReverseSortDirectionSchema = enumSchema(
-  ["asc", "desc"],
-  {
-    title: "OpensteerReverseSortDirection"
-  }
-);
-var opensteerObservationClusterRelationshipKindSchema = enumSchema(
-  ["seed", "preflight", "redirect", "retry", "duplicate", "follow-on"],
-  { title: "OpensteerObservationClusterRelationshipKind" }
-);
-var opensteerReverseReportKindSchema = enumSchema(
-  ["discovery", "package"],
-  { title: "OpensteerReverseReportKind" }
-);
-var opensteerReversePackageKindSchema = enumSchema(
-  ["portable-http", "browser-workflow"],
-  { title: "OpensteerReversePackageKind" }
-);
-var opensteerReversePackageReadinessSchema = enumSchema(
-  ["runnable", "draft", "unsupported"],
-  { title: "OpensteerReversePackageReadiness" }
-);
-var opensteerBodyCodecKindSchema = enumSchema(
-  [
-    "json",
-    "form-urlencoded",
-    "multipart",
-    "graphql",
-    "persisted-graphql",
-    "text",
-    "opaque-binary",
-    "sse",
-    "websocket-json",
-    "websocket-text",
-    "unknown"
-  ],
-  { title: "OpensteerBodyCodecKind" }
-);
-var opensteerExecutableResolverKindSchema = enumSchema(
-  [
-    "literal",
-    "cookie",
-    "storage",
-    "prior-record",
-    "binding",
-    "candidate",
-    "case",
-    "state-snapshot",
-    "artifact",
-    "manual",
-    "runtime-managed"
-  ],
-  { title: "OpensteerExecutableResolverKind" }
-);
-var opensteerValueReferenceKindSchema = enumSchema(
-  [
-    "literal",
-    "resolver",
-    "binding",
-    "candidate",
-    "case",
-    "record",
-    "artifact",
-    "state-snapshot",
-    "runtime",
-    "manual"
-  ],
-  { title: "OpensteerValueReferenceKind" }
-);
-var opensteerRuntimeValueKeySchema = enumSchema(
-  ["pageRef", "packageId", "caseId", "candidateId", "objective"],
-  { title: "OpensteerRuntimeValueKey" }
-);
-var 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" }
-);
-var opensteerReverseRequirementKindSchema = enumSchema(
-  ["resolver", "guard", "workflow-step", "state", "channel", "unsupported"],
-  { title: "OpensteerReverseRequirementKind" }
-);
-var opensteerReverseRequirementStatusSchema = enumSchema(
-  ["required", "recommended"],
-  { title: "OpensteerReverseRequirementStatus" }
-);
-var opensteerReverseSuggestedEditKindSchema = enumSchema(
-  [
-    "set-resolver",
-    "attach-trace",
-    "replace-workflow",
-    "patch-step-input",
-    "switch-state-source",
-    "inspect-evidence",
-    "mark-unsupported"
-  ],
-  { title: "OpensteerReverseSuggestedEditKind" }
-);
-var jsonValueSchema2 = defineSchema({
-  title: "JsonValue"
-});
-var 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"]
-  }
-);
-var opensteerValueTemplateSchema = defineSchema({
-  title: "OpensteerValueTemplate"
-});
-var 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"
-  }
-);
-var opensteerBodyCodecDescriptorSchema = objectSchema(
-  {
-    kind: opensteerBodyCodecKindSchema,
-    contentType: stringSchema({ minLength: 1 }),
-    operationName: stringSchema({ minLength: 1 }),
-    fieldPaths: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerBodyCodecDescriptor",
-    required: ["kind", "fieldPaths"]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"]
-  }
-);
-var opensteerChannelDescriptorSchema = objectSchema(
-  {
-    kind: opensteerReverseChannelKindSchema,
-    recordKind: networkRecordKindSchema,
-    method: stringSchema({ minLength: 1 }),
-    url: stringSchema({ minLength: 1 }),
-    subprotocol: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerChannelDescriptor",
-    required: ["kind", "recordKind", "url"]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var opensteerReverseWorkflowStepSchema = oneOfSchema(
-  [
-    opensteerReverseOperationWorkflowStepSchema,
-    opensteerReverseAwaitRecordWorkflowStepSchema,
-    opensteerReverseAssertWorkflowStepSchema
-  ],
-  {
-    title: "OpensteerReverseWorkflowStep"
-  }
-);
-var 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"]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var 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"]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"
-    ]
-  }
-);
-var 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"]
-  }
-);
-var 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"
-  }
-);
-var 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"
-  }
-);
-var opensteerReverseQuerySortSchema = objectSchema(
-  {
-    preset: opensteerReverseSortPresetSchema,
-    keys: arraySchema(
-      objectSchema(
-        {
-          key: opensteerReverseSortKeySchema,
-          direction: opensteerReverseSortDirectionSchema
-        },
-        {
-          title: "OpensteerReverseSortTerm",
-          required: ["key"]
-        }
-      ),
-      { minItems: 1 }
-    )
-  },
-  {
-    title: "OpensteerReverseQuerySort"
-  }
-);
-var 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"]
-  }
-);
-var opensteerReverseQueryRecordItemSchema = objectSchema(
-  {
-    record: opensteerReverseObservedRecordSchema,
-    candidateIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseQueryRecordItem",
-    required: ["record", "candidateIds"]
-  }
-);
-var opensteerReverseQueryClusterItemSchema = objectSchema(
-  {
-    cluster: opensteerObservationClusterSchema,
-    candidateIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseQueryClusterItem",
-    required: ["cluster", "candidateIds"]
-  }
-);
-var 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
+  {
+    urlPattern: stringSchema({ minLength: 1 }),
+    mode: sandboxAjaxModeSchema,
+    mockResponse: objectSchema(
+      {
+        status: integerSchema({ minimum: 100, maximum: 599 }),
+        headers: recordSchema(stringSchema(), {
+          title: "SandboxAjaxMockHeaders"
+        }),
+        body: stringSchema()
+      },
+      {
+        title: "SandboxAjaxMockResponse",
+        required: ["status"]
+      }
+    )
   },
   {
-    title: "OpensteerReversePackageListInput"
+    title: "SandboxAjaxRoute",
+    required: ["urlPattern", "mode"]
   }
 );
-objectSchema(
+var 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(
+var 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(
+var 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"]
   }
 );
 
@@ -6356,12 +4429,12 @@ var opensteerDomExtractInputSchema = defineSchema({
   ),
   anyOf: [defineSchema({ required: ["persist"] }), defineSchema({ required: ["schema"] })]
 });
-var jsonValueSchema3 = recordSchema({}, { title: "JsonValueRecord" });
+var jsonValueSchema2 = recordSchema({}, { title: "JsonValueRecord" });
 var opensteerDomExtractOutputSchema = objectSchema(
   {
     data: oneOfSchema(
       [
-        jsonValueSchema3,
+        jsonValueSchema2,
         arraySchema({}),
         stringSchema(),
         numberSchema(),
@@ -6764,7 +4837,7 @@ var opensteerSemanticOperationSpecificationsBase = [
   }),
   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: []
@@ -8084,76 +6157,6 @@ var FilesystemRequestPlanRegistry = class extends FilesystemRegistryStore {
     });
   }
 };
-var 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);
-  }
-};
-var 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);
-  }
-};
 var FilesystemInteractionTraceRegistry = class extends FilesystemRegistryStore {
   constructor(rootPath) {
     super(rootPath, ["registry", "interaction-traces"]);
@@ -8189,163 +6192,15 @@ var FilesystemInteractionTraceRegistry = class extends FilesystemRegistryStore {
     return key === void 0 ? records : records.filter((record) => record.key === key);
   }
 };
-var 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;
-    });
-  }
-};
-var 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);
-  }
-};
-var 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 createDescriptorRegistry(rootPath) {
   return new FilesystemDescriptorRegistry(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 TAG_DELIMITER = "";
 var NODE_SQLITE_SPECIFIER = `node:${"sqlite"}`;
 var SAVED_NETWORK_SQLITE_SUPPORT_ERROR = "Saved-network operations require Node's built-in SQLite support. Use a Node runtime with node:sqlite enabled.";
@@ -9258,20 +7113,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);
@@ -9297,13 +7142,8 @@ async function createFilesystemOpensteerWorkspace(options) {
     registry: {
       descriptors,
       requestPlans,
-      authRecipes,
-      recipes,
       savedNetwork,
-      reverseCases,
-      interactionTraces,
-      reversePackages,
-      reverseReports
+      interactionTraces
     },
     lock(task) {
       return withFilesystemLock(lockPath, task);