rea-agents
    Preparing search index...
    • Resolve one named application contract without relying on array position.

      Parameters

      • name:
            | "trace_application_feature"
            | "compare_application_versions"
            | "compare_javascript_export_shapes"
            | "run_controlled_replay"
            | "prepare_node_characterization"
            | "execute_node_characterization"
            | "commit_reconstruction_coverage"
            | "query_reconstruction_coverage"

      Returns
          | {
              annotations: DerivedToolAnnotations;
              description: "Trace a typed literal seed through an authenticated JavaScript Application Graph supplied as full Evidence or an Evidence ID returned earlier in this session. Explicit direction, depth, node, edge, and path bounds apply. Original static, native, passive-runtime, inferred, and unknown authorities remain distinct; native addon handoffs never open a provider or execute the application.";
              effects: ToolEffects;
              examples: readonly [
                  {
                      input: {
                          application_evidence_id: string;
                          direction: "both";
                          seed: {
                              case_sensitive: boolean;
                              kind: "module";
                              match: "exact";
                              value: string;
                          };
                      };
                      title: "Trace one module seed through a retained application graph";
                  },
              ];
              inputSchema: ZodObject<
                  {
                      application: ZodOptional<
                          ZodObject<
                              {
                                  analysis_profile: ZodOptional<
                                      ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  authority: ZodEnum<
                                      {
                                          "analyst-inference": "analyst-inference";
                                          "controlled-replay": "controlled-replay";
                                          "external-service": "external-service";
                                          "historical-reference": "historical-reference";
                                          "shipped-artifact": "shipped-artifact";
                                      },
                                  >;
                                  confidence: ZodEnum<
                                      {
                                          derived: "derived";
                                          inferred: "inferred";
                                          observed: "observed";
                                      },
                                  >;
                                  environment: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodString;
                                              id: ZodString;
                                              isolation: ZodEnum<(...)>;
                                              platform: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  evidence_id: ZodString;
                                  evidence_links: ZodArray<ZodString>;
                                  limitations: ZodArray<ZodString>;
                                  locations: ZodArray<
                                      ZodDiscriminatedUnion<
                                          [
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                          ],
                                          "kind",
                                      >,
                                  >;
                                  normalized_result: ZodJSONSchema;
                                  operation: ZodString;
                                  parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                  predicate_type: ZodString;
                                  provider: ZodObject<
                                      {
                                          id: ZodString;
                                          name: ZodString;
                                          version: ZodNullable<ZodString>;
                                      },
                                      $strip,
                                  >;
                                  raw_result: ZodNullable<ZodJSONSchema>;
                                  schema_version: ZodLiteral<2>;
                                  subject: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodNullable<(...)>;
                                              digest: ZodObject<(...), (...)>;
                                              format: ZodEnum<(...)>;
                                              local_path: ZodString;
                                              name: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                              },
                              $strict,
                          >,
                      >;
                      application_evidence_id: ZodOptional<ZodString>;
                      direction: ZodDefault<
                          ZodEnum<
                              { both: "both"; incoming: "incoming"; outgoing: "outgoing" },
                          >,
                      >;
                      limits: ZodDefault<
                          ZodObject<
                              {
                                  max_depth: ZodDefault<ZodNumber>;
                                  max_edges: ZodDefault<ZodNumber>;
                                  max_nodes: ZodDefault<ZodNumber>;
                                  max_paths: ZodDefault<ZodNumber>;
                                  max_seed_matches: ZodDefault<ZodNumber>;
                              },
                              $strict,
                          >,
                      >;
                      native_observation_evidence_ids: ZodDefault<ZodArray<ZodString>>;
                      native_observations: ZodDefault<
                          ZodArray<
                              ZodObject<
                                  {
                                      analysis_profile: ZodOptional<
                                          ZodObject<
                                              {
                                                  digest: ...;
                                                  parameters: ...;
                                                  provider: ...;
                                                  provider_profile_schema_version: ...;
                                                  schema_version: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                          >,
                      >;
                      seed: ZodObject<
                          {
                              case_sensitive: ZodDefault<ZodBoolean>;
                              kind: ZodEnum<
                                  {
                                      api: "api";
                                      channel: "channel";
                                      module: "module";
                                      "native-export": "native-export";
                                      "node-id": "node-id";
                                      route: "route";
                                      string: "string";
                                  },
                              >;
                              match: ZodDefault<
                                  ZodNullable<ZodEnum<{ contains: "contains"; exact: "exact" }>>,
                              >;
                              value: ZodString;
                          },
                          $strict,
                      >;
                  },
                  $strict,
              >;
              kind: "application";
              name: "trace_application_feature";
              outputSchema: ZodObject<
                  {
                      evidence_id: ZodString;
                      evidence_uri: ZodString;
                      result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                  },
                  $strict,
              >;
              title: string;
          }
          | {
              annotations: DerivedToolAnnotations;
              description: "Compare two authenticated JavaScript Application Graph versions supplied as full Evidence or Evidence IDs returned earlier in this session. Uses unique-only exact digest, module source digest, source-map identity, structural fingerprint, and non-module semantic-key tiers. Reports added, removed, changed, ambiguous, and unknown entities plus a bounded changed_from graph without fuzzy or module-ordinal pairing.";
              effects: ToolEffects;
              examples: readonly [
                  {
                      input: { left_evidence_id: string; right_evidence_id: string };
                      title: "Compare authenticated static and reconciled application graphs";
                  },
              ];
              inputSchema: ZodObject<
                  {
                      left: ZodOptional<
                          ZodObject<
                              {
                                  analysis_profile: ZodOptional<
                                      ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  authority: ZodEnum<
                                      {
                                          "analyst-inference": "analyst-inference";
                                          "controlled-replay": "controlled-replay";
                                          "external-service": "external-service";
                                          "historical-reference": "historical-reference";
                                          "shipped-artifact": "shipped-artifact";
                                      },
                                  >;
                                  confidence: ZodEnum<
                                      {
                                          derived: "derived";
                                          inferred: "inferred";
                                          observed: "observed";
                                      },
                                  >;
                                  environment: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodString;
                                              id: ZodString;
                                              isolation: ZodEnum<(...)>;
                                              platform: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  evidence_id: ZodString;
                                  evidence_links: ZodArray<ZodString>;
                                  limitations: ZodArray<ZodString>;
                                  locations: ZodArray<
                                      ZodDiscriminatedUnion<
                                          [
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                          ],
                                          "kind",
                                      >,
                                  >;
                                  normalized_result: ZodJSONSchema;
                                  operation: ZodString;
                                  parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                  predicate_type: ZodString;
                                  provider: ZodObject<
                                      {
                                          id: ZodString;
                                          name: ZodString;
                                          version: ZodNullable<ZodString>;
                                      },
                                      $strip,
                                  >;
                                  raw_result: ZodNullable<ZodJSONSchema>;
                                  schema_version: ZodLiteral<2>;
                                  subject: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodNullable<(...)>;
                                              digest: ZodObject<(...), (...)>;
                                              format: ZodEnum<(...)>;
                                              local_path: ZodString;
                                              name: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                              },
                              $strict,
                          >,
                      >;
                      left_evidence_id: ZodOptional<ZodString>;
                      left_native_observation_evidence_ids: ZodDefault<ZodArray<ZodString>>;
                      left_native_observations: ZodDefault<
                          ZodArray<
                              ZodObject<
                                  {
                                      analysis_profile: ZodOptional<
                                          ZodObject<
                                              {
                                                  digest: ...;
                                                  parameters: ...;
                                                  provider: ...;
                                                  provider_profile_schema_version: ...;
                                                  schema_version: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                          >,
                      >;
                      limits: ZodDefault<
                          ZodObject<
                              {
                                  max_candidate_nodes: ZodDefault<ZodNumber>;
                                  max_comparison_items: ZodDefault<ZodNumber>;
                                  max_graph_edges: ZodDefault<ZodNumber>;
                                  max_graph_nodes: ZodDefault<ZodNumber>;
                              },
                              $strict,
                          >,
                      >;
                      right: ZodOptional<
                          ZodObject<
                              {
                                  analysis_profile: ZodOptional<
                                      ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  authority: ZodEnum<
                                      {
                                          "analyst-inference": "analyst-inference";
                                          "controlled-replay": "controlled-replay";
                                          "external-service": "external-service";
                                          "historical-reference": "historical-reference";
                                          "shipped-artifact": "shipped-artifact";
                                      },
                                  >;
                                  confidence: ZodEnum<
                                      {
                                          derived: "derived";
                                          inferred: "inferred";
                                          observed: "observed";
                                      },
                                  >;
                                  environment: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodString;
                                              id: ZodString;
                                              isolation: ZodEnum<(...)>;
                                              platform: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  evidence_id: ZodString;
                                  evidence_links: ZodArray<ZodString>;
                                  limitations: ZodArray<ZodString>;
                                  locations: ZodArray<
                                      ZodDiscriminatedUnion<
                                          [
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                          ],
                                          "kind",
                                      >,
                                  >;
                                  normalized_result: ZodJSONSchema;
                                  operation: ZodString;
                                  parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                  predicate_type: ZodString;
                                  provider: ZodObject<
                                      {
                                          id: ZodString;
                                          name: ZodString;
                                          version: ZodNullable<ZodString>;
                                      },
                                      $strip,
                                  >;
                                  raw_result: ZodNullable<ZodJSONSchema>;
                                  schema_version: ZodLiteral<2>;
                                  subject: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodNullable<(...)>;
                                              digest: ZodObject<(...), (...)>;
                                              format: ZodEnum<(...)>;
                                              local_path: ZodString;
                                              name: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                              },
                              $strict,
                          >,
                      >;
                      right_evidence_id: ZodOptional<ZodString>;
                      right_native_observation_evidence_ids: ZodDefault<ZodArray<ZodString>>;
                      right_native_observations: ZodDefault<
                          ZodArray<
                              ZodObject<
                                  {
                                      analysis_profile: ZodOptional<
                                          ZodObject<
                                              {
                                                  digest: ...;
                                                  parameters: ...;
                                                  provider: ...;
                                                  provider_profile_schema_version: ...;
                                                  schema_version: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                          >,
                      >;
                      unknown_registry_approved: ZodOptional<ZodLiteral<true>>;
                  },
                  $strict,
              >;
              kind: "application";
              name: "compare_application_versions";
              outputSchema: ZodObject<
                  {
                      evidence_id: ZodString;
                      evidence_uri: ZodString;
                      result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                  },
                  $strict,
              >;
              title: string;
          }
          | {
              annotations: DerivedToolAnnotations;
              description: "Compare bounded static return shapes for one exact module/export selector on each authenticated JavaScript Application Graph, supplied as full Evidence or session Evidence IDs. Variants pair only by reciprocal unique literal discriminants; dynamic values, incomplete properties, and ambiguous variants remain unknown. Reports JSON Pointer changes and recommends controlled replay separately without executing JavaScript.";
              effects: ToolEffects;
              examples: readonly [
                  {
                      input: {
                          left_evidence_id: string;
                          left_export_name: string;
                          left_module_path: string;
                          right_evidence_id: string;
                          right_export_name: string;
                          right_module_path: string;
                      };
                      title: "Compare one exact parser export without execution";
                  },
              ];
              inputSchema: ZodObject<
                  {
                      left: ZodOptional<
                          ZodObject<
                              {
                                  analysis_profile: ZodOptional<
                                      ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  authority: ZodEnum<
                                      {
                                          "analyst-inference": "analyst-inference";
                                          "controlled-replay": "controlled-replay";
                                          "external-service": "external-service";
                                          "historical-reference": "historical-reference";
                                          "shipped-artifact": "shipped-artifact";
                                      },
                                  >;
                                  confidence: ZodEnum<
                                      {
                                          derived: "derived";
                                          inferred: "inferred";
                                          observed: "observed";
                                      },
                                  >;
                                  environment: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodString;
                                              id: ZodString;
                                              isolation: ZodEnum<(...)>;
                                              platform: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  evidence_id: ZodString;
                                  evidence_links: ZodArray<ZodString>;
                                  limitations: ZodArray<ZodString>;
                                  locations: ZodArray<
                                      ZodDiscriminatedUnion<
                                          [
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                          ],
                                          "kind",
                                      >,
                                  >;
                                  normalized_result: ZodJSONSchema;
                                  operation: ZodString;
                                  parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                  predicate_type: ZodString;
                                  provider: ZodObject<
                                      {
                                          id: ZodString;
                                          name: ZodString;
                                          version: ZodNullable<ZodString>;
                                      },
                                      $strip,
                                  >;
                                  raw_result: ZodNullable<ZodJSONSchema>;
                                  schema_version: ZodLiteral<2>;
                                  subject: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodNullable<(...)>;
                                              digest: ZodObject<(...), (...)>;
                                              format: ZodEnum<(...)>;
                                              local_path: ZodString;
                                              name: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                              },
                              $strict,
                          >,
                      >;
                      left_evidence_id: ZodOptional<ZodString>;
                      left_export_name: ZodString;
                      left_module_path: ZodString;
                      limits: ZodDefault<
                          ZodObject<
                              {
                                  max_candidate_exports: ZodDefault<ZodNumber>;
                                  max_changes: ZodDefault<ZodNumber>;
                                  max_return_variants: ZodDefault<ZodNumber>;
                              },
                              $strict,
                          >,
                      >;
                      right: ZodOptional<
                          ZodObject<
                              {
                                  analysis_profile: ZodOptional<
                                      ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  authority: ZodEnum<
                                      {
                                          "analyst-inference": "analyst-inference";
                                          "controlled-replay": "controlled-replay";
                                          "external-service": "external-service";
                                          "historical-reference": "historical-reference";
                                          "shipped-artifact": "shipped-artifact";
                                      },
                                  >;
                                  confidence: ZodEnum<
                                      {
                                          derived: "derived";
                                          inferred: "inferred";
                                          observed: "observed";
                                      },
                                  >;
                                  environment: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodString;
                                              id: ZodString;
                                              isolation: ZodEnum<(...)>;
                                              platform: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  evidence_id: ZodString;
                                  evidence_links: ZodArray<ZodString>;
                                  limitations: ZodArray<ZodString>;
                                  locations: ZodArray<
                                      ZodDiscriminatedUnion<
                                          [
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                          ],
                                          "kind",
                                      >,
                                  >;
                                  normalized_result: ZodJSONSchema;
                                  operation: ZodString;
                                  parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                  predicate_type: ZodString;
                                  provider: ZodObject<
                                      {
                                          id: ZodString;
                                          name: ZodString;
                                          version: ZodNullable<ZodString>;
                                      },
                                      $strip,
                                  >;
                                  raw_result: ZodNullable<ZodJSONSchema>;
                                  schema_version: ZodLiteral<2>;
                                  subject: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodNullable<(...)>;
                                              digest: ZodObject<(...), (...)>;
                                              format: ZodEnum<(...)>;
                                              local_path: ZodString;
                                              name: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                              },
                              $strict,
                          >,
                      >;
                      right_evidence_id: ZodOptional<ZodString>;
                      right_export_name: ZodString;
                      right_module_path: ZodString;
                      unknown_registry_approved: ZodOptional<ZodLiteral<true>>;
                  },
                  $strict,
              >;
              kind: "application";
              name: "compare_javascript_export_shapes";
              outputSchema: ZodObject<
                  {
                      evidence_id: ZodString;
                      evidence_uri: ZodString;
                      result: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                  },
                  $strict,
              >;
              title: string;
          }
          | {
              annotations: DerivedToolAnnotations;
              description: "Plan or execute a content-bound extracted-module JavaScript replay inside the Linux Bubblewrap, seccomp, and cgroup boundary. Execution requires approved: true and the exact plan digest. Supports deterministic boundary cases and optional left/right differential comparison; observations have controlled-replay authority and do not claim real application runtime behavior.";
              effects: ToolEffects;
              examples: readonly [
                  {
                      input: {
                          approved: false;
                          cases: [{ arguments: [""]; case_id: "empty" }];
                          determinism: {
                              clock_iso: "2000-01-01T00:00:00.000Z";
                              locale: "en-US";
                              platform: "linux";
                              random_seed: 0;
                              timezone: "UTC";
                          };
                          left: {
                              entry_alias: "parser";
                              entry_export: "default";
                              modules: [
                                  {
                                      alias: "parser";
                                      dependencies: {};
                                      format: "esm";
                                      path: "/approved/parser.mjs";
                                      role: "module";
                                  },
                              ];
                          };
                          limits: {
                              cpu_quota_percent: 50;
                              input_bytes: 262144;
                              memory_bytes: 134217728;
                              module_bytes: 4194304;
                              output_bytes: 524288;
                              protocol_bytes: 16777216;
                              result_depth: 16;
                              result_nodes: 10000;
                              stderr_bytes: 32768;
                              tasks: 8;
                              tmpfs_bytes: 16777216;
                              wall_time_ms: 3000;
                          };
                          mode: "plan";
                      };
                      title: "Plan one extracted ESM parser replay";
                  },
              ];
              inputSchema: ZodObject<
                  {
                      approved: ZodDefault<ZodBoolean>;
                      cases: ZodDefault<
                          ZodArray<
                              ZodObject<
                                  { arguments: ZodArray<ZodJSONSchema>; case_id: ZodString },
                                  $strict,
                              >,
                          >,
                      >;
                      determinism: ZodDefault<
                          ZodObject<
                              {
                                  clock_iso: ZodDefault<ZodISODateTime>;
                                  locale: ZodDefault<ZodLiteral<"en-US">>;
                                  platform: ZodDefault<ZodLiteral<"linux">>;
                                  random_seed: ZodDefault<ZodNumber>;
                                  timezone: ZodDefault<ZodLiteral<"UTC">>;
                              },
                              $strict,
                          >,
                      >;
                      generator: ZodOptional<
                          ZodObject<
                              {
                                  count: ZodNumber;
                                  preset: ZodEnum<
                                      {
                                          "clipboard-boundaries": "clipboard-boundaries";
                                          "parser-boundaries": "parser-boundaries";
                                          "sanitizer-boundaries": "sanitizer-boundaries";
                                      },
                                  >;
                                  seed: ZodNumber;
                              },
                              $strict,
                          >,
                      >;
                      left: ZodObject<
                          {
                              entry_alias: ZodString;
                              entry_export: ZodDefault<ZodString>;
                              modules: ZodArray<
                                  ZodObject<
                                      {
                                          alias: ZodString;
                                          dependencies: ZodDefault<ZodRecord<(...), (...)>>;
                                          format: ZodEnum<{ "commonjs-factory": ...; esm: ... }>;
                                          path: ZodString;
                                          role: ZodDefault<ZodEnum<(...)>>;
                                      },
                                      $strict,
                                  >,
                              >;
                          },
                          $strict,
                      >;
                      limits: ZodDefault<
                          ZodObject<
                              {
                                  cpu_quota_percent: ZodDefault<ZodNumber>;
                                  input_bytes: ZodDefault<ZodNumber>;
                                  memory_bytes: ZodDefault<ZodNumber>;
                                  module_bytes: ZodDefault<ZodNumber>;
                                  output_bytes: ZodDefault<ZodNumber>;
                                  protocol_bytes: ZodDefault<ZodNumber>;
                                  result_depth: ZodDefault<ZodNumber>;
                                  result_nodes: ZodDefault<ZodNumber>;
                                  stderr_bytes: ZodDefault<ZodNumber>;
                                  tasks: ZodDefault<ZodNumber>;
                                  tmpfs_bytes: ZodDefault<ZodNumber>;
                                  wall_time_ms: ZodDefault<ZodNumber>;
                              },
                              $strict,
                          >,
                      >;
                      mode: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                      plan_digest: ZodOptional<ZodString>;
                      reproducer_export: ZodOptional<
                          ZodObject<
                              {
                                  approved: ZodBoolean;
                                  include_sources: ZodDefault<ZodBoolean>;
                                  path: ZodString;
                              },
                              $strict,
                          >,
                      >;
                      right: ZodOptional<
                          ZodObject<
                              {
                                  entry_alias: ZodString;
                                  entry_export: ZodDefault<ZodString>;
                                  modules: ZodArray<
                                      ZodObject<
                                          {
                                              alias: ZodString;
                                              dependencies: ZodDefault<(...)>;
                                              format: ZodEnum<(...)>;
                                              path: ZodString;
                                              role: ZodDefault<(...)>;
                                          },
                                          $strict,
                                      >,
                                  >;
                              },
                              $strict,
                          >,
                      >;
                  },
                  $strict,
              >;
              kind: "application";
              name: "run_controlled_replay";
              outputSchema: ZodObject<
                  {
                      evidence: ZodNullable<
                          ZodObject<
                              {
                                  analysis_profile: ZodOptional<
                                      ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  authority: ZodEnum<
                                      {
                                          "analyst-inference": "analyst-inference";
                                          "controlled-replay": "controlled-replay";
                                          "external-service": "external-service";
                                          "historical-reference": "historical-reference";
                                          "shipped-artifact": "shipped-artifact";
                                      },
                                  >;
                                  confidence: ZodEnum<
                                      {
                                          derived: "derived";
                                          inferred: "inferred";
                                          observed: "observed";
                                      },
                                  >;
                                  environment: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodString;
                                              id: ZodString;
                                              isolation: ZodEnum<(...)>;
                                              platform: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  evidence_id: ZodString;
                                  evidence_links: ZodArray<ZodString>;
                                  limitations: ZodArray<ZodString>;
                                  locations: ZodArray<
                                      ZodDiscriminatedUnion<
                                          [
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                          ],
                                          "kind",
                                      >,
                                  >;
                                  normalized_result: ZodObject<
                                      {
                                          cleanup: ZodObject<
                                              { residual_resources: ...; state: ... },
                                              $strict,
                                          >;
                                          comparison: ZodOptional<ZodArray<(...)>>;
                                          limitations: ZodArray<ZodString>;
                                          outcomes: ZodArray<ZodObject<(...), (...)>>;
                                          plan_digest: ZodString;
                                          reproducer: ZodNullable<ZodDiscriminatedUnion<(...), (...)>>;
                                          schema_version: ZodLiteral<1>;
                                          stderr: ZodString;
                                          termination: ZodEnum<
                                              {
                                                  cancelled: ...;
                                                  completed: ...;
                                                  crash: ...;
                                                  oom: ...;
                                                  protocol_error: ...;
                                                  timeout: ...;
                                              },
                                          >;
                                      },
                                      $strict,
                                  >;
                                  operation: ZodString;
                                  parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                  predicate_type: ZodString;
                                  provider: ZodObject<
                                      {
                                          id: ZodString;
                                          name: ZodString;
                                          version: ZodNullable<ZodString>;
                                      },
                                      $strip,
                                  >;
                                  raw_result: ZodNullable<ZodJSONSchema>;
                                  schema_version: ZodLiteral<2>;
                                  subject: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodNullable<(...)>;
                                              digest: ZodObject<(...), (...)>;
                                              format: ZodEnum<(...)>;
                                              local_path: ZodString;
                                              name: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                              },
                              $strict,
                          >,
                      >;
                      phase: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                      plan: ZodNullable<
                          ZodObject<
                              {
                                  cases: ZodArray<
                                      ZodObject<
                                          {
                                              arguments: ZodArray<(...)>;
                                              case_id: ZodString;
                                              sha256: ZodString;
                                          },
                                          $strict,
                                      >,
                                  >;
                                  determinism: ZodObject<
                                      {
                                          clock_iso: ZodDefault<ZodISODateTime>;
                                          locale: ZodDefault<ZodLiteral<(...)>>;
                                          platform: ZodDefault<ZodLiteral<(...)>>;
                                          random_seed: ZodDefault<ZodNumber>;
                                          timezone: ZodDefault<ZodLiteral<(...)>>;
                                      },
                                      $strict,
                                  >;
                                  effects: ZodArray<ZodString>;
                                  filesystem: ZodObject<
                                      {
                                          host_writes: ZodLiteral<false>;
                                          private_tmpfs_bytes: ZodNumber;
                                      },
                                      $strict,
                                  >;
                                  left: ZodObject<
                                      {
                                          entry_alias: ZodString;
                                          entry_export: ZodString;
                                          modules: ZodArray<ZodObject<(...), (...)>>;
                                      },
                                      $strict,
                                  >;
                                  limits: ZodObject<
                                      {
                                          cpu_quota_percent: ZodDefault<ZodNumber>;
                                          input_bytes: ZodDefault<ZodNumber>;
                                          memory_bytes: ZodDefault<ZodNumber>;
                                          module_bytes: ZodDefault<ZodNumber>;
                                          output_bytes: ZodDefault<ZodNumber>;
                                          protocol_bytes: ZodDefault<ZodNumber>;
                                          result_depth: ZodDefault<ZodNumber>;
                                          result_nodes: ZodDefault<ZodNumber>;
                                          stderr_bytes: ZodDefault<ZodNumber>;
                                          tasks: ZodDefault<ZodNumber>;
                                          tmpfs_bytes: ZodDefault<ZodNumber>;
                                          wall_time_ms: ZodDefault<ZodNumber>;
                                      },
                                      $strict,
                                  >;
                                  network: ZodLiteral<"none">;
                                  plan_digest: ZodString;
                                  policy_sha256: ZodString;
                                  policy_version: ZodLiteral<"linux-bwrap-systemd-v1">;
                                  reproducer_export: ZodNullable<
                                      ZodObject<
                                          {
                                              authority: ZodLiteral<(...)>;
                                              include_sources: ZodBoolean;
                                              path: ZodString;
                                          },
                                          $strict,
                                      >,
                                  >;
                                  right: ZodOptional<
                                      ZodObject<
                                          {
                                              entry_alias: ZodString;
                                              entry_export: ZodString;
                                              modules: ZodArray<(...)>;
                                          },
                                          $strict,
                                      >,
                                  >;
                                  runtime: ZodObject<
                                      {
                                          executable: ZodObject<
                                              { path: ...; sha256: ...; version: ... },
                                              $strict,
                                          >;
                                          read_only_files: ZodArray<ZodObject<(...), (...)>>;
                                          worker: ZodObject<
                                              { path: ...; sha256: ...; version: ... },
                                              $strict,
                                          >;
                                      },
                                      $strict,
                                  >;
                                  sandbox: ZodObject<
                                      {
                                          bubblewrap: ZodObject<
                                              { path: ...; sha256: ...; version: ... },
                                              $strict,
                                          >;
                                          seccomp_sha256: ZodString;
                                          shell: ZodObject<{ path: ...; sha256: ...; version: ... }, $strict>;
                                          systemctl: ZodObject<
                                              { path: ...; sha256: ...; version: ... },
                                              $strict,
                                          >;
                                          systemd_run: ZodObject<
                                              { path: ...; sha256: ...; version: ... },
                                              $strict,
                                          >;
                                      },
                                      $strict,
                                  >;
                                  schema_version: ZodLiteral<1>;
                              },
                              $strict,
                          >,
                      >;
                      source_evidence: ZodArray<
                          ZodObject<
                              {
                                  analysis_profile: ZodOptional<
                                      ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  authority: ZodEnum<
                                      {
                                          "analyst-inference": "analyst-inference";
                                          "controlled-replay": "controlled-replay";
                                          "external-service": "external-service";
                                          "historical-reference": "historical-reference";
                                          "shipped-artifact": "shipped-artifact";
                                      },
                                  >;
                                  confidence: ZodEnum<
                                      {
                                          derived: "derived";
                                          inferred: "inferred";
                                          observed: "observed";
                                      },
                                  >;
                                  environment: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodString;
                                              id: ZodString;
                                              isolation: ZodEnum<(...)>;
                                              platform: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                                  evidence_id: ZodString;
                                  evidence_links: ZodArray<ZodString>;
                                  limitations: ZodArray<ZodString>;
                                  locations: ZodArray<
                                      ZodDiscriminatedUnion<
                                          [
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                              ZodObject<(...), (...)>,
                                          ],
                                          "kind",
                                      >,
                                  >;
                                  normalized_result: ZodObject<
                                      {
                                          cleanup: ZodObject<
                                              { residual_resources: ...; state: ... },
                                              $strict,
                                          >;
                                          comparison: ZodOptional<ZodArray<(...)>>;
                                          limitations: ZodArray<ZodString>;
                                          outcomes: ZodArray<ZodObject<(...), (...)>>;
                                          plan_digest: ZodString;
                                          reproducer: ZodNullable<ZodDiscriminatedUnion<(...), (...)>>;
                                          schema_version: ZodLiteral<1>;
                                          stderr: ZodString;
                                          termination: ZodEnum<
                                              {
                                                  cancelled: ...;
                                                  completed: ...;
                                                  crash: ...;
                                                  oom: ...;
                                                  protocol_error: ...;
                                                  timeout: ...;
                                              },
                                          >;
                                      },
                                      $strict,
                                  >;
                                  operation: ZodString;
                                  parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                  predicate_type: ZodString;
                                  provider: ZodObject<
                                      {
                                          id: ZodString;
                                          name: ZodString;
                                          version: ZodNullable<ZodString>;
                                      },
                                      $strip,
                                  >;
                                  raw_result: ZodNullable<ZodJSONSchema>;
                                  schema_version: ZodLiteral<2>;
                                  subject: ZodNullable<
                                      ZodObject<
                                          {
                                              architecture: ZodNullable<(...)>;
                                              digest: ZodObject<(...), (...)>;
                                              format: ZodEnum<(...)>;
                                              local_path: ZodString;
                                              name: ZodString;
                                          },
                                          $strip,
                                      >,
                                  >;
                              },
                              $strict,
                          >,
                      >;
                  },
                  $strict,
              >;
              title: string;
          }
          | {
              annotations: DerivedToolAnnotations;
              description: "Prepare a hash-bound Node/JavaScript characterization plan and deterministic reversible export transformation without executing target code. The exact source, selected byte range, runtime closure, sandbox profile, cases, and limits are committed for separate execution approval.";
              effects: ToolEffects;
              examples: readonly [
                  {
                      input: Record<string, JSONType>;
                      title: "Prepare one exact bundled callable characterization";
                  },
              ];
              inputSchema: ZodObject<
                  {
                      expected_effect: ZodEnum<
                          { "observation-only": "observation-only"; pure: "pure" },
                      >;
                      instrumentation: ZodObject<
                          {
                              artifact_path: ZodString;
                              artifact_sha256: ZodString;
                              selection: ZodObject<
                                  {
                                      byte_end: ZodNumber;
                                      byte_start: ZodNumber;
                                      export_name: ZodString;
                                      selected_sha256: ZodString;
                                  },
                                  $strict,
                              >;
                          },
                          $strict,
                      >;
                      preparation_approved: ZodLiteral<true>;
                      replay: ZodObject<
                          {
                              approved: ZodDefault<ZodBoolean>;
                              cases: ZodDefault<
                                  ZodArray<
                                      ZodObject<
                                          { arguments: ZodArray<(...)>; case_id: ZodString },
                                          $strict,
                                      >,
                                  >,
                              >;
                              determinism: ZodDefault<
                                  ZodObject<
                                      {
                                          clock_iso: ZodDefault<ZodISODateTime>;
                                          locale: ZodDefault<ZodLiteral<(...)>>;
                                          platform: ZodDefault<ZodLiteral<(...)>>;
                                          random_seed: ZodDefault<ZodNumber>;
                                          timezone: ZodDefault<ZodLiteral<(...)>>;
                                      },
                                      $strict,
                                  >,
                              >;
                              generator: ZodOptional<
                                  ZodObject<
                                      {
                                          count: ZodNumber;
                                          preset: ZodEnum<
                                              {
                                                  "clipboard-boundaries": ...;
                                                  "parser-boundaries": ...;
                                                  "sanitizer-boundaries": ...;
                                              },
                                          >;
                                          seed: ZodNumber;
                                      },
                                      $strict,
                                  >,
                              >;
                              left: ZodObject<
                                  {
                                      entry_alias: ZodString;
                                      entry_export: ZodDefault<ZodString>;
                                      modules: ZodArray<
                                          ZodObject<
                                              {
                                                  alias: ...;
                                                  dependencies: ...;
                                                  format: ...;
                                                  path: ...;
                                                  role: ...;
                                              },
                                              $strict,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >;
                              limits: ZodDefault<
                                  ZodObject<
                                      {
                                          cpu_quota_percent: ZodDefault<ZodNumber>;
                                          input_bytes: ZodDefault<ZodNumber>;
                                          memory_bytes: ZodDefault<ZodNumber>;
                                          module_bytes: ZodDefault<ZodNumber>;
                                          output_bytes: ZodDefault<ZodNumber>;
                                          protocol_bytes: ZodDefault<ZodNumber>;
                                          result_depth: ZodDefault<ZodNumber>;
                                          result_nodes: ZodDefault<ZodNumber>;
                                          stderr_bytes: ZodDefault<ZodNumber>;
                                          tasks: ZodDefault<ZodNumber>;
                                          tmpfs_bytes: ZodDefault<ZodNumber>;
                                          wall_time_ms: ZodDefault<ZodNumber>;
                                      },
                                      $strict,
                                  >,
                              >;
                              mode: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                              plan_digest: ZodOptional<ZodString>;
                              reproducer_export: ZodOptional<
                                  ZodObject<
                                      {
                                          approved: ZodBoolean;
                                          include_sources: ZodDefault<ZodBoolean>;
                                          path: ZodString;
                                      },
                                      $strict,
                                  >,
                              >;
                              right: ZodOptional<
                                  ZodObject<
                                      {
                                          entry_alias: ZodString;
                                          entry_export: ZodDefault<ZodString>;
                                          modules: ZodArray<ZodObject<(...), (...)>>;
                                      },
                                      $strict,
                                  >,
                              >;
                          },
                          $strict,
                      >;
                      selected_alias: ZodString;
                  },
                  $strict,
              >;
              kind: "application";
              name: "prepare_node_characterization";
              outputSchema: ZodObject<
                  {
                      phase: ZodLiteral<"preparation">;
                      plan: ZodObject<
                          {
                              allowed_boundaries: ZodArray<ZodString>;
                              artifact: ZodObject<
                                  { byte_length: ZodNumber; path: ZodString; sha256: ZodString },
                                  $strict,
                              >;
                              authority: ZodObject<
                                  {
                                      execution_approved: ZodLiteral<false>;
                                      network: ZodEnum<{ loopback: "loopback"; none: "none" }>;
                                      preparation_approved: ZodLiteral<true>;
                                      provider_owned_process_only: ZodLiteral<true>;
                                  },
                                  $strict,
                              >;
                              callable: ZodObject<
                                  {
                                      callable_id: ZodString;
                                      export_name: ZodString;
                                      module_id: ZodString;
                                      selector_sha256: ZodString;
                                      semantic_evidence_id: ZodNullable<ZodString>;
                                  },
                                  $strict,
                              >;
                              determinism: ZodObject<
                                  {
                                      clock: ZodEnum<{ fixed: "fixed"; real: "real" }>;
                                      identifiers: ZodEnum<
                                          { deterministic: "deterministic"; runtime: "runtime" },
                                      >;
                                      randomness: ZodEnum<{ seeded: "seeded"; system: "system" }>;
                                      seed: ZodNumber;
                                  },
                                  $strict,
                              >;
                              expected_effect: ZodEnum<
                                  {
                                      "bounded-effects": "bounded-effects";
                                      "observation-only": "observation-only";
                                      pure: "pure";
                                  },
                              >;
                              isolated_home: ZodString;
                              limits: ZodObject<
                                  {
                                      idle_timeout_ms: ZodNumber;
                                      max_bytes: ZodNumber;
                                      max_calls: ZodNumber;
                                      max_files: ZodNumber;
                                      max_handles: ZodNumber;
                                      max_processes: ZodNumber;
                                      timeout_ms: ZodNumber;
                                  },
                                  $strict,
                              >;
                              plan_sha256: ZodString;
                              preparation_sha256: ZodString;
                              runtime: ZodObject<
                                  {
                                      executable_path: ZodString;
                                      executable_sha256: ZodString;
                                      family: ZodString;
                                      profile_sha256: ZodString;
                                      provider_id: ZodString;
                                      version: ZodString;
                                  },
                                  $strict,
                              >;
                              schema_version: ZodLiteral<1>;
                              working_directory: ZodString;
                          },
                          $strict,
                      >;
                      replay: ZodObject<
                          {
                              evidence: ZodNullable<
                                  ZodObject<
                                      {
                                          analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                          authority: ZodEnum<
                                              {
                                                  "analyst-inference": ...;
                                                  "controlled-replay": ...;
                                                  "external-service": ...;
                                                  "historical-reference": ...;
                                                  "shipped-artifact": ...;
                                              },
                                          >;
                                          confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                          environment: ZodNullable<ZodObject<(...), (...)>>;
                                          evidence_id: ZodString;
                                          evidence_links: ZodArray<ZodString>;
                                          limitations: ZodArray<ZodString>;
                                          locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                          normalized_result: ZodObject<
                                              {
                                                  cleanup: ...;
                                                  comparison: ...;
                                                  limitations: ...;
                                                  outcomes: ...;
                                                  plan_digest: ...;
                                                  reproducer: ...;
                                                  schema_version: ...;
                                                  stderr: ...;
                                                  termination: ...;
                                              },
                                              $strict,
                                          >;
                                          operation: ZodString;
                                          parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                          predicate_type: ZodString;
                                          provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                          raw_result: ZodNullable<ZodJSONSchema>;
                                          schema_version: ZodLiteral<2>;
                                          subject: ZodNullable<ZodObject<(...), (...)>>;
                                      },
                                      $strict,
                                  >,
                              >;
                              phase: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                              plan: ZodNullable<
                                  ZodObject<
                                      {
                                          cases: ZodArray<ZodObject<(...), (...)>>;
                                          determinism: ZodObject<
                                              {
                                                  clock_iso: ...;
                                                  locale: ...;
                                                  platform: ...;
                                                  random_seed: ...;
                                                  timezone: ...;
                                              },
                                              $strict,
                                          >;
                                          effects: ZodArray<ZodString>;
                                          filesystem: ZodObject<
                                              { host_writes: ...; private_tmpfs_bytes: ... },
                                              $strict,
                                          >;
                                          left: ZodObject<
                                              { entry_alias: ...; entry_export: ...; modules: ... },
                                              $strict,
                                          >;
                                          limits: ZodObject<
                                              {
                                                  cpu_quota_percent: ...;
                                                  input_bytes: ...;
                                                  memory_bytes: ...;
                                                  module_bytes: ...;
                                                  output_bytes: ...;
                                                  protocol_bytes: ...;
                                                  result_depth: ...;
                                                  result_nodes: ...;
                                                  stderr_bytes: ...;
                                                  tasks: ...;
                                                  tmpfs_bytes: ...;
                                                  wall_time_ms: ...;
                                              },
                                              $strict,
                                          >;
                                          network: ZodLiteral<"none">;
                                          plan_digest: ZodString;
                                          policy_sha256: ZodString;
                                          policy_version: ZodLiteral<"linux-bwrap-systemd-v1">;
                                          reproducer_export: ZodNullable<ZodObject<(...), (...)>>;
                                          right: ZodOptional<ZodObject<(...), (...)>>;
                                          runtime: ZodObject<
                                              { executable: ...; read_only_files: ...; worker: ... },
                                              $strict,
                                          >;
                                          sandbox: ZodObject<
                                              {
                                                  bubblewrap: ...;
                                                  seccomp_sha256: ...;
                                                  shell: ...;
                                                  systemctl: ...;
                                                  systemd_run: ...;
                                              },
                                              $strict,
                                          >;
                                          schema_version: ZodLiteral<1>;
                                      },
                                      $strict,
                                  >,
                              >;
                              source_evidence: ZodArray<
                                  ZodObject<
                                      {
                                          analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                          authority: ZodEnum<
                                              {
                                                  "analyst-inference": ...;
                                                  "controlled-replay": ...;
                                                  "external-service": ...;
                                                  "historical-reference": ...;
                                                  "shipped-artifact": ...;
                                              },
                                          >;
                                          confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                          environment: ZodNullable<ZodObject<(...), (...)>>;
                                          evidence_id: ZodString;
                                          evidence_links: ZodArray<ZodString>;
                                          limitations: ZodArray<ZodString>;
                                          locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                          normalized_result: ZodObject<
                                              {
                                                  cleanup: ...;
                                                  comparison: ...;
                                                  limitations: ...;
                                                  outcomes: ...;
                                                  plan_digest: ...;
                                                  reproducer: ...;
                                                  schema_version: ...;
                                                  stderr: ...;
                                                  termination: ...;
                                              },
                                              $strict,
                                          >;
                                          operation: ZodString;
                                          parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                          predicate_type: ZodString;
                                          provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                          raw_result: ZodNullable<ZodJSONSchema>;
                                          schema_version: ZodLiteral<2>;
                                          subject: ZodNullable<ZodObject<(...), (...)>>;
                                      },
                                      $strict,
                                  >,
                              >;
                          },
                          $strict,
                      >;
                      schema_version: ZodLiteral<1>;
                      transformation: ZodObject<
                          {
                              artifact_path: ZodString;
                              inserted_ranges: ZodArray<
                                  ZodObject<
                                      {
                                          byte_end: ZodNumber;
                                          byte_start: ZodNumber;
                                          inserted_sha256: ZodString;
                                          purpose: ZodEnum<
                                              {
                                                  "export-binding": ...;
                                                  "factory-prefix": ...;
                                                  "factory-suffix": ...;
                                              },
                                          >;
                                      },
                                      $strict,
                                  >,
                              >;
                              instrumented_byte_length: ZodNumber;
                              instrumented_sha256: ZodString;
                              kind: ZodLiteral<"commonjs-factory-export-v1">;
                              original_byte_length: ZodNumber;
                              original_sha256: ZodString;
                              output_format: ZodLiteral<"commonjs-factory">;
                              schema_version: ZodLiteral<1>;
                              selected_range: ZodObject<
                                  {
                                      byte_end: ZodNumber;
                                      byte_start: ZodNumber;
                                      selected_sha256: ZodString;
                                  },
                                  $strict,
                              >;
                              source_map: ZodLiteral<null>;
                          },
                          $strict,
                      >;
                      transformation_evidence: ZodUnion<
                          readonly [
                              ZodObject<
                                  {
                                      analysis_profile: ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >;
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                              ZodObject<
                                  {
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                          ],
                      >;
                  },
                  $strict,
              >;
              title: string;
          }
          | {
              annotations: DerivedToolAnnotations;
              description: "Recompute and execute one separately approved exact Node characterization plan in the owned controlled-replay boundary. Returns transformation, replay, cleanup, and provider-neutral characterization Evidence v2; stale plans fail before execution.";
              effects: ToolEffects;
              examples: readonly [
                  {
                      input: {
                          approved_plan_sha256: string;
                          execution_approved: true;
                          preparation: Record<string, JSONType>;
                      };
                      title: "Execute one approved exact characterization plan";
                  },
              ];
              inputSchema: ZodObject<
                  {
                      approved_plan_sha256: ZodString;
                      execution_approved: ZodLiteral<true>;
                      preparation: ZodObject<
                          {
                              expected_effect: ZodEnum<
                                  { "observation-only": "observation-only"; pure: "pure" },
                              >;
                              instrumentation: ZodObject<
                                  {
                                      artifact_path: ZodString;
                                      artifact_sha256: ZodString;
                                      selection: ZodObject<
                                          {
                                              byte_end: ZodNumber;
                                              byte_start: ZodNumber;
                                              export_name: ZodString;
                                              selected_sha256: ZodString;
                                          },
                                          $strict,
                                      >;
                                  },
                                  $strict,
                              >;
                              preparation_approved: ZodLiteral<true>;
                              replay: ZodObject<
                                  {
                                      approved: ZodDefault<ZodBoolean>;
                                      cases: ZodDefault<ZodArray<ZodObject<(...), (...)>>>;
                                      determinism: ZodDefault<
                                          ZodObject<
                                              {
                                                  clock_iso: ...;
                                                  locale: ...;
                                                  platform: ...;
                                                  random_seed: ...;
                                                  timezone: ...;
                                              },
                                              $strict,
                                          >,
                                      >;
                                      generator: ZodOptional<
                                          ZodObject<{ count: ...; preset: ...; seed: ... }, $strict>,
                                      >;
                                      left: ZodObject<
                                          {
                                              entry_alias: ZodString;
                                              entry_export: ZodDefault<(...)>;
                                              modules: ZodArray<(...)>;
                                          },
                                          $strict,
                                      >;
                                      limits: ZodDefault<
                                          ZodObject<
                                              {
                                                  cpu_quota_percent: ...;
                                                  input_bytes: ...;
                                                  memory_bytes: ...;
                                                  module_bytes: ...;
                                                  output_bytes: ...;
                                                  protocol_bytes: ...;
                                                  result_depth: ...;
                                                  result_nodes: ...;
                                                  stderr_bytes: ...;
                                                  tasks: ...;
                                                  tmpfs_bytes: ...;
                                                  wall_time_ms: ...;
                                              },
                                              $strict,
                                          >,
                                      >;
                                      mode: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                                      plan_digest: ZodOptional<ZodString>;
                                      reproducer_export: ZodOptional<
                                          ZodObject<
                                              { approved: ...; include_sources: ...; path: ... },
                                              $strict,
                                          >,
                                      >;
                                      right: ZodOptional<
                                          ZodObject<
                                              { entry_alias: ...; entry_export: ...; modules: ... },
                                              $strict,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >;
                              selected_alias: ZodString;
                          },
                          $strict,
                      >;
                  },
                  $strict,
              >;
              kind: "application";
              name: "execute_node_characterization";
              outputSchema: ZodObject<
                  {
                      evidence: ZodUnion<
                          readonly [
                              ZodObject<
                                  {
                                      analysis_profile: ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >;
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                              ZodObject<
                                  {
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                          ],
                      >;
                      phase: ZodLiteral<"execution">;
                      plan: ZodObject<
                          {
                              allowed_boundaries: ZodArray<ZodString>;
                              artifact: ZodObject<
                                  { byte_length: ZodNumber; path: ZodString; sha256: ZodString },
                                  $strict,
                              >;
                              authority: ZodObject<
                                  {
                                      execution_approved: ZodLiteral<false>;
                                      network: ZodEnum<{ loopback: "loopback"; none: "none" }>;
                                      preparation_approved: ZodLiteral<true>;
                                      provider_owned_process_only: ZodLiteral<true>;
                                  },
                                  $strict,
                              >;
                              callable: ZodObject<
                                  {
                                      callable_id: ZodString;
                                      export_name: ZodString;
                                      module_id: ZodString;
                                      selector_sha256: ZodString;
                                      semantic_evidence_id: ZodNullable<ZodString>;
                                  },
                                  $strict,
                              >;
                              determinism: ZodObject<
                                  {
                                      clock: ZodEnum<{ fixed: "fixed"; real: "real" }>;
                                      identifiers: ZodEnum<
                                          { deterministic: "deterministic"; runtime: "runtime" },
                                      >;
                                      randomness: ZodEnum<{ seeded: "seeded"; system: "system" }>;
                                      seed: ZodNumber;
                                  },
                                  $strict,
                              >;
                              expected_effect: ZodEnum<
                                  {
                                      "bounded-effects": "bounded-effects";
                                      "observation-only": "observation-only";
                                      pure: "pure";
                                  },
                              >;
                              isolated_home: ZodString;
                              limits: ZodObject<
                                  {
                                      idle_timeout_ms: ZodNumber;
                                      max_bytes: ZodNumber;
                                      max_calls: ZodNumber;
                                      max_files: ZodNumber;
                                      max_handles: ZodNumber;
                                      max_processes: ZodNumber;
                                      timeout_ms: ZodNumber;
                                  },
                                  $strict,
                              >;
                              plan_sha256: ZodString;
                              preparation_sha256: ZodString;
                              runtime: ZodObject<
                                  {
                                      executable_path: ZodString;
                                      executable_sha256: ZodString;
                                      family: ZodString;
                                      profile_sha256: ZodString;
                                      provider_id: ZodString;
                                      version: ZodString;
                                  },
                                  $strict,
                              >;
                              schema_version: ZodLiteral<1>;
                              working_directory: ZodString;
                          },
                          $strict,
                      >;
                      replay: ZodObject<
                          {
                              evidence: ZodNullable<
                                  ZodObject<
                                      {
                                          analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                          authority: ZodEnum<
                                              {
                                                  "analyst-inference": ...;
                                                  "controlled-replay": ...;
                                                  "external-service": ...;
                                                  "historical-reference": ...;
                                                  "shipped-artifact": ...;
                                              },
                                          >;
                                          confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                          environment: ZodNullable<ZodObject<(...), (...)>>;
                                          evidence_id: ZodString;
                                          evidence_links: ZodArray<ZodString>;
                                          limitations: ZodArray<ZodString>;
                                          locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                          normalized_result: ZodObject<
                                              {
                                                  cleanup: ...;
                                                  comparison: ...;
                                                  limitations: ...;
                                                  outcomes: ...;
                                                  plan_digest: ...;
                                                  reproducer: ...;
                                                  schema_version: ...;
                                                  stderr: ...;
                                                  termination: ...;
                                              },
                                              $strict,
                                          >;
                                          operation: ZodString;
                                          parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                          predicate_type: ZodString;
                                          provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                          raw_result: ZodNullable<ZodJSONSchema>;
                                          schema_version: ZodLiteral<2>;
                                          subject: ZodNullable<ZodObject<(...), (...)>>;
                                      },
                                      $strict,
                                  >,
                              >;
                              phase: ZodEnum<{ execute: "execute"; plan: "plan" }>;
                              plan: ZodNullable<
                                  ZodObject<
                                      {
                                          cases: ZodArray<ZodObject<(...), (...)>>;
                                          determinism: ZodObject<
                                              {
                                                  clock_iso: ...;
                                                  locale: ...;
                                                  platform: ...;
                                                  random_seed: ...;
                                                  timezone: ...;
                                              },
                                              $strict,
                                          >;
                                          effects: ZodArray<ZodString>;
                                          filesystem: ZodObject<
                                              { host_writes: ...; private_tmpfs_bytes: ... },
                                              $strict,
                                          >;
                                          left: ZodObject<
                                              { entry_alias: ...; entry_export: ...; modules: ... },
                                              $strict,
                                          >;
                                          limits: ZodObject<
                                              {
                                                  cpu_quota_percent: ...;
                                                  input_bytes: ...;
                                                  memory_bytes: ...;
                                                  module_bytes: ...;
                                                  output_bytes: ...;
                                                  protocol_bytes: ...;
                                                  result_depth: ...;
                                                  result_nodes: ...;
                                                  stderr_bytes: ...;
                                                  tasks: ...;
                                                  tmpfs_bytes: ...;
                                                  wall_time_ms: ...;
                                              },
                                              $strict,
                                          >;
                                          network: ZodLiteral<"none">;
                                          plan_digest: ZodString;
                                          policy_sha256: ZodString;
                                          policy_version: ZodLiteral<"linux-bwrap-systemd-v1">;
                                          reproducer_export: ZodNullable<ZodObject<(...), (...)>>;
                                          right: ZodOptional<ZodObject<(...), (...)>>;
                                          runtime: ZodObject<
                                              { executable: ...; read_only_files: ...; worker: ... },
                                              $strict,
                                          >;
                                          sandbox: ZodObject<
                                              {
                                                  bubblewrap: ...;
                                                  seccomp_sha256: ...;
                                                  shell: ...;
                                                  systemctl: ...;
                                                  systemd_run: ...;
                                              },
                                              $strict,
                                          >;
                                          schema_version: ZodLiteral<1>;
                                      },
                                      $strict,
                                  >,
                              >;
                              source_evidence: ZodArray<
                                  ZodObject<
                                      {
                                          analysis_profile: ZodOptional<ZodObject<(...), (...)>>;
                                          authority: ZodEnum<
                                              {
                                                  "analyst-inference": ...;
                                                  "controlled-replay": ...;
                                                  "external-service": ...;
                                                  "historical-reference": ...;
                                                  "shipped-artifact": ...;
                                              },
                                          >;
                                          confidence: ZodEnum<{ derived: ...; inferred: ...; observed: ... }>;
                                          environment: ZodNullable<ZodObject<(...), (...)>>;
                                          evidence_id: ZodString;
                                          evidence_links: ZodArray<ZodString>;
                                          limitations: ZodArray<ZodString>;
                                          locations: ZodArray<ZodDiscriminatedUnion<(...), (...)>>;
                                          normalized_result: ZodObject<
                                              {
                                                  cleanup: ...;
                                                  comparison: ...;
                                                  limitations: ...;
                                                  outcomes: ...;
                                                  plan_digest: ...;
                                                  reproducer: ...;
                                                  schema_version: ...;
                                                  stderr: ...;
                                                  termination: ...;
                                              },
                                              $strict,
                                          >;
                                          operation: ZodString;
                                          parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                          predicate_type: ZodString;
                                          provider: ZodObject<{ id: ...; name: ...; version: ... }, $strip>;
                                          raw_result: ZodNullable<ZodJSONSchema>;
                                          schema_version: ZodLiteral<2>;
                                          subject: ZodNullable<ZodObject<(...), (...)>>;
                                      },
                                      $strict,
                                  >,
                              >;
                          },
                          $strict,
                      >;
                      schema_version: ZodLiteral<1>;
                      transformation: ZodObject<
                          {
                              artifact_path: ZodString;
                              inserted_ranges: ZodArray<
                                  ZodObject<
                                      {
                                          byte_end: ZodNumber;
                                          byte_start: ZodNumber;
                                          inserted_sha256: ZodString;
                                          purpose: ZodEnum<
                                              {
                                                  "export-binding": ...;
                                                  "factory-prefix": ...;
                                                  "factory-suffix": ...;
                                              },
                                          >;
                                      },
                                      $strict,
                                  >,
                              >;
                              instrumented_byte_length: ZodNumber;
                              instrumented_sha256: ZodString;
                              kind: ZodLiteral<"commonjs-factory-export-v1">;
                              original_byte_length: ZodNumber;
                              original_sha256: ZodString;
                              output_format: ZodLiteral<"commonjs-factory">;
                              schema_version: ZodLiteral<1>;
                              selected_range: ZodObject<
                                  {
                                      byte_end: ZodNumber;
                                      byte_start: ZodNumber;
                                      selected_sha256: ZodString;
                                  },
                                  $strict,
                              >;
                              source_map: ZodLiteral<null>;
                          },
                          $strict,
                      >;
                      transformation_evidence: ZodUnion<
                          readonly [
                              ZodObject<
                                  {
                                      analysis_profile: ZodObject<
                                          {
                                              digest: ZodString;
                                              parameters: ZodRecord<(...), (...)>;
                                              provider: ZodObject<(...), (...)>;
                                              provider_profile_schema_version: ZodNumber;
                                              schema_version: ZodLiteral<(...)>;
                                          },
                                          $strip,
                                      >;
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                              ZodObject<
                                  {
                                      authority: ZodEnum<
                                          {
                                              "analyst-inference": "analyst-inference";
                                              "controlled-replay": "controlled-replay";
                                              "external-service": "external-service";
                                              "historical-reference": "historical-reference";
                                              "shipped-artifact": "shipped-artifact";
                                          },
                                      >;
                                      confidence: ZodEnum<
                                          {
                                              derived: "derived";
                                              inferred: "inferred";
                                              observed: "observed";
                                          },
                                      >;
                                      environment: ZodNullable<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      evidence_id: ZodString;
                                      evidence_links: ZodArray<ZodString>;
                                      limitations: ZodArray<ZodString>;
                                      locations: ZodArray<
                                          ZodDiscriminatedUnion<
                                              [(...), (...), (...), (...), (...)],
                                              "kind",
                                          >,
                                      >;
                                      normalized_result: ZodJSONSchema;
                                      operation: ZodString;
                                      parameters: ZodRecord<ZodString, ZodJSONSchema>;
                                      predicate_type: ZodString;
                                      provider: ZodObject<
                                          { id: ZodString; name: ZodString; version: ZodNullable<(...)> },
                                          $strip,
                                      >;
                                      raw_result: ZodNullable<ZodJSONSchema>;
                                      schema_version: ZodLiteral<2>;
                                      subject: ZodNullable<
                                          ZodObject<
                                              {
                                                  architecture: ...;
                                                  digest: ...;
                                                  format: ...;
                                                  local_path: ...;
                                                  name: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strict,
                              >,
                          ],
                      >;
                  },
                  $strict,
              >;
              title: string;
          }
          | {
              annotations: DerivedToolAnnotations;
              description: "Atomically commit one canonical evidence-backed reconstruction coverage workspace revision under an approved root. CAS revisions reject lost updates; every Evidence and residual-unknown reference must resolve in the embedded canonical bundle.";
              effects: ToolEffects;
              examples: readonly [
                  {
                      input: {
                          approved: true;
                          expected_revision: null;
                          workspace: Record<string, JSONType>;
                          workspace_path: "/approved/coverage.json";
                      };
                      title: "Commit the first canonical coverage revision";
                  },
              ];
              inputSchema: ZodObject<
                  {
                      approved: ZodLiteral<true>;
                      expected_revision: ZodNullable<ZodNumber>;
                      workspace: ZodObject<
                          {
                              artifacts: ZodArray<
                                  ZodObject<
                                      {
                                          artifact_id: ZodString;
                                          artifact_sha256: ZodString;
                                          environment_sha256: ZodString;
                                          evidence_ids: ZodArray<ZodString>;
                                          version: ZodString;
                                      },
                                      $strict,
                                  >,
                              >;
                              boundaries: ZodArray<
                                  ZodObject<
                                      {
                                          allowed_dispositions: ZodArray<ZodEnum<(...)>>;
                                          allowed_unknown_ids: ZodArray<ZodString>;
                                          boundary_id: ZodString;
                                          required_claim_ids: ZodArray<ZodString>;
                                          required_package_proof_kinds: ZodArray<ZodEnum<(...)>>;
                                          required_surface_ids: ZodArray<ZodString>;
                                          title: ZodString;
                                      },
                                      $strict,
                                  >,
                              >;
                              claims: ZodArray<
                                  ZodObject<
                                      {
                                          claim_id: ZodString;
                                          kind: ZodString;
                                          required_authority: ZodEnum<
                                              {
                                                  "controlled-replay": ...;
                                                  external: ...;
                                                  "live-observation": ...;
                                                  "shipped-artifact": ...;
                                              },
                                          >;
                                          required_dimensions: ZodArray<ZodString>;
                                          surface_ids: ZodArray<ZodString>;
                                          title: ZodString;
                                      },
                                      $strict,
                                  >,
                              >;
                              contradictions: ZodArray<
                                  ZodObject<
                                      {
                                          claim_ids: ZodArray<ZodString>;
                                          contradiction_id: ZodString;
                                          evidence_ids: ZodArray<ZodString>;
                                          status: ZodEnum<{ active: ...; resolved: ... }>;
                                          surface_ids: ZodArray<ZodString>;
                                      },
                                      $strict,
                                  >,
                              >;
                              evidence_bundle: ZodObject<
                                  {
                                      artifacts: ZodArray<
                                          ZodObject<
                                              { architecture: ...; digest: ...; format: ... },
                                              $strip,
                                          >,
                                      >;
                                      bundle_version: ZodLiteral<2>;
                                      captures: ZodArray<
                                          ZodObject<{ evidence_id: ...; predicate_type: ... }, $strip>,
                                      >;
                                      environments: ZodArray<
                                          ZodObject<
                                              { architecture: ...; id: ...; isolation: ...; platform: ... },
                                              $strip,
                                          >,
                                      >;
                                      providers: ZodArray<
                                          ZodObject<{ id: ...; name: ...; version: ... }, $strip>,
                                      >;
                                      records: ZodArray<ZodUnion<readonly [(...), (...)]>>;
                                      scenarios: ZodArray<
                                          ZodObject<
                                              { authority: ...; evidence_id: ...; operation: ... },
                                              $strip,
                                          >,
                                      >;
                                      unknowns: ZodArray<
                                          ZodObject<
                                              {
                                                  contradicting_evidence_ids: ...;
                                                  domain: ...;
                                                  mutation_evidence_ids: ...;
                                                  previous_revision_digest: ...;
                                                  question: ...;
                                                  recommended_probes: ...;
                                                  registry_version: ...;
                                                  relationships: ...;
                                                  required_authority: ...;
                                                  required_confidence: ...;
                                                  required_environment: ...;
                                                  resolution: ...;
                                                  revision: ...;
                                                  revision_digest: ...;
                                                  scope_digest: ...;
                                                  severity: ...;
                                                  status: ...;
                                                  supporting_evidence_ids: ...;
                                                  unknown_id: ...;
                                              },
                                              $strip,
                                          >,
                                      >;
                                  },
                                  $strip,
                              >;
                              name: ZodString;
                              owners: ZodArray<
                                  ZodObject<
                                      {
                                          ownership: ZodDiscriminatedUnion<[(...), (...)], "disposition">;
                                          surface_id: ZodString;
                                      },
                                      $strict,
                                  >,
                              >;
                              package_proofs: ZodArray<
                                  ZodObject<
                                      {
                                          artifact_sha256s: ZodArray<ZodString>;
                                          evidence_ids: ZodArray<ZodString>;
                                          kind: ZodEnum<
                                              {
                                                  "authority-independence": ...;
                                                  build: ...;
                                                  "clean-install": ...;
                                                  "package-contents": ...;
                                                  "runtime-routing": ...;
                                              },
                                          >;
                                          proof_id: ZodString;
                                          status: ZodEnum<
                                              {
                                                  fail: ...;
                                                  pass: ...;
                                                  skipped: ...;
                                                  unknown: ...;
                                                  unsupported: ...;
                                              },
                                          >;
                                      },
                                      $strict,
                                  >,
                              >;
                              previous_revision_sha256: ZodNullable<ZodString>;
                              residual_unknown_ids: ZodArray<ZodString>;
                              revision: ZodNumber;
                              revision_sha256: ZodString;
                              schema_version: ZodLiteral<1>;
                              surfaces: ZodArray<
                                  ZodObject<
                                      {
                                          artifact_id: ZodString;
                                          authority: ZodEnum<
                                              {
                                                  derived: ...;
                                                  external: ...;
                                                  historical: ...;
                                                  inferred: ...;
                                                  observed: ...;
                                              },
                                          >;
                                          dependency_surface_ids: ZodArray<ZodString>;
                                          evidence_ids: ZodArray<ZodString>;
                                          family: ZodString;
                                          location: ZodString;
                                          occurrence_id: ZodNullable<ZodString>;
                                          surface_id: ZodString;
                                      },
                                      $strict,
                                  >,
                              >;
                              verifier_contracts: ZodArray<
                                  ZodObject<
                                      {
                                          authority: ZodEnum<
                                              {
                                                  "controlled-replay": ...;
                                                  external: ...;
                                                  "live-observation": ...;
                                                  "shipped-artifact": ...;
                                              },
                                          >;
                                          claim_ids: ZodArray<ZodString>;
                                          contract_sha256: ZodString;
                                          dimensions: ZodArray<ZodString>;
                                          max_age_ms: ZodNumber;
                                          minimum_repeats: ZodNumber;
                                          normalization_removes_dimensions: ZodLiteral<false>;
                                          normalization_sha256: ZodString;
                                          verifier_id: ZodString;
                                      },
                                      $strict,
                                  >,
                              >;
                              verifier_results: ZodArray<
                                  ZodObject<
                                      {
                                          artifact_sha256s: ZodArray<ZodString>;
                                          contract_sha256: ZodString;
                                          covered_claim_ids: ZodArray<ZodString>;
                                          covered_dimensions: ZodArray<ZodString>;
                                          evidence_ids: ZodArray<ZodString>;
                                          normalization_sha256: ZodString;
                                          observed_at: ZodString;
                                          owner_sha256s: ZodArray<ZodString>;
                                          repeats: ZodNumber;
                                          status: ZodEnum<
                                              {
                                                  fail: ...;
                                                  pass: ...;
                                                  skipped: ...;
                                                  truncated: ...;
                                                  unknown: ...;
                                                  unsupported: ...;
                                              },
                                          >;
                                          verifier_id: ZodString;
                                      },
                                      $strict,
                                  >,
                              >;
                              workspace_id: ZodString;
                          },
                          $strict,
                      >;
                      workspace_path: ZodString;
                  },
                  $strict,
              >;
              kind: "application";
              name: "commit_reconstruction_coverage";
              outputSchema: ZodObject<
                  {
                      bytes: ZodNumber;
                      evidence_records: ZodNumber;
                      revision: ZodNumber;
                      revision_sha256: ZodString;
                      workspace_id: ZodString;
                      workspace_path: ZodString;
                  },
                  $strict,
              >;
              title: string;
          }
          | {
              annotations: DerivedToolAnnotations;
              description: "Evaluate one named reconstruction boundary from a canonical coverage workspace. Missing ownership or inventory is partial; stale, weak, truncated, skipped, or unresolved proof is unknown; contradictions, failed proof, missing owners, and authority routing fail closed.";
              effects: ToolEffects;
              examples: readonly [
                  {
                      input: {
                          boundary_id: "replacement.cli";
                          workspace_path: "/approved/coverage.json";
                      };
                      title: "Evaluate one replacement boundary";
                  },
              ];
              inputSchema: ZodObject<
                  { boundary_id: ZodString; workspace_path: ZodString },
                  $strict,
              >;
              kind: "application";
              name: "query_reconstruction_coverage";
              outputSchema: ZodObject<
                  {
                      boundary_id: ZodString;
                      evidence_ids: ZodArray<ZodString>;
                      reasons: ZodArray<
                          ZodObject<
                              {
                                  code: ZodEnum<
                                      {
                                          "active-contradiction": "active-contradiction";
                                          "active-unknown": "active-unknown";
                                          "authority-routing-detected": "authority-routing-detected";
                                          "authority-routing-unknown": "authority-routing-unknown";
                                          "claim-missing": "claim-missing";
                                          "dependency-surface-missing": "dependency-surface-missing";
                                          "disposition-not-allowed": "disposition-not-allowed";
                                          "owner-distribution-unknown": "owner-distribution-unknown";
                                          "owner-duplicate": "owner-duplicate";
                                          "owner-missing": "owner-missing";
                                          "owner-path-missing": "owner-path-missing";
                                          "owner-path-unknown": "owner-path-unknown";
                                          "owner-undistributed": "owner-undistributed";
                                          "package-proof-failed": "package-proof-failed";
                                          "package-proof-missing": "package-proof-missing";
                                          "package-proof-unknown": "package-proof-unknown";
                                          "surface-missing": "surface-missing";
                                          "verifier-duplicate": "verifier-duplicate";
                                          "verifier-failed": "verifier-failed";
                                          "verifier-missing": "verifier-missing";
                                          "verifier-result-incompatible": "verifier-result-incompatible";
                                          "verifier-result-missing": "verifier-result-missing";
                                          "verifier-result-stale": "verifier-result-stale";
                                          "verifier-unknown": "verifier-unknown";
                                      },
                                  >;
                                  detail: ZodString;
                                  subject_id: ZodString;
                              },
                              $strict,
                          >,
                      >;
                      recommended_probes: ZodArray<
                          ZodObject<
                              {
                                  operation: ZodString;
                                  rationale: ZodString;
                                  subject_id: ZodString;
                              },
                              $strict,
                          >,
                      >;
                      status: ZodEnum<
                          {
                              failed: "failed";
                              partial: "partial";
                              ready: "ready";
                              unknown: "unknown";
                          },
                      >;
                      summary: ZodObject<
                          {
                              reasons: ZodNumber;
                              required_claims: ZodNumber;
                              required_surfaces: ZodNumber;
                          },
                          $strict,
                      >;
                      workspace_revision_sha256: ZodString;
                  },
                  $strict,
              >;
              title: string;
          }